1
00:00:00,000 --> 00:00:02,240
En lo que nos apoyamos por debajo siempre es lo mismo.

2
00:00:02,240 --> 00:00:04,560
Primero la programación estructural, por supuesto,

3
00:00:04,560 --> 00:00:07,120
porque los métodos cuando hagan cositas,

4
00:00:07,120 --> 00:00:10,680
lo harán con las estrategias de decisión, de bucles, etcétera.

5
00:00:10,680 --> 00:00:14,760
Nos apoyamos en eso para los métodos.

6
00:00:14,760 --> 00:00:18,160
Y luego nos apoyamos en cómo se declaran las clases,

7
00:00:18,160 --> 00:00:22,720
cómo se crean objetos y cómo se pueden llamar a los métodos de objetos.

8
00:00:22,720 --> 00:00:24,960
Y ya está, nos apoyamos sobre eso.

9
00:00:24,960 --> 00:00:27,240
Pero sobre eso ya se hacen aplicaciones grandes

10
00:00:27,240 --> 00:00:29,320
donde la dificultad es no perderse, ¿vale?

11
00:00:29,320 --> 00:00:31,640
No perderse, esa es la dificultad.

12
00:00:31,640 --> 00:00:34,480
Bueno, pues este era un ejemplito de eso,

13
00:00:34,480 --> 00:00:37,560
como la que hicimos la de clientes y pedidos, pues esta de móviles.

14
00:00:40,560 --> 00:00:43,720
Es un poco rara, pero la idea era cambiar de temática,

15
00:00:43,720 --> 00:00:47,480
no estar siempre con alumnos, clientes, etcétera, ¿vale?

16
00:00:47,480 --> 00:00:49,200
Cambiar un poco de temática.

17
00:00:49,200 --> 00:00:52,520
Simular esa situación, ¿no?

18
00:00:52,520 --> 00:00:56,800
De un móvil que tiene aplicaciones que puede instalar en un almacén y

19
00:00:56,800 --> 00:01:01,120
luego aplicaciones instaladas, etcétera.

20
00:01:01,120 --> 00:01:06,160
Vale, pues vamos a terminarla antes de seguir viendo cosas.

21
00:01:06,160 --> 00:01:13,880
Bueno, recordad que el enunciado debía estar aquí en Descartes.

22
00:01:13,880 --> 00:01:14,380
¿Verdad?

23
00:01:24,120 --> 00:01:25,120
No, esto no era.

24
00:01:38,120 --> 00:01:38,920
Esto era, ¿no?

25
00:01:38,920 --> 00:01:40,320
El enunciado.

26
00:01:40,320 --> 00:01:43,680
Vale, recordad que aquí la parte de diseño ya la teníamos

27
00:01:43,680 --> 00:01:46,960
hecha, ya nos decían qué clases teníamos que hacer,

28
00:01:46,960 --> 00:01:49,840
qué propiedades tenían que tener y qué métodos.

29
00:01:49,840 --> 00:01:53,040
Esa parte de diseño ya estaba.

30
00:01:53,040 --> 00:01:55,440
Pero no es el caso siempre.

31
00:01:55,440 --> 00:02:00,440
A veces nos dirán, oye, necesito gestionar esto.

32
00:02:00,440 --> 00:02:05,920
Y a partir de ahí ya uno decide qué clases representan esa situación y

33
00:02:05,920 --> 00:02:10,240
qué debe hacer cada clase para gestionar las necesidades del que

34
00:02:10,240 --> 00:02:11,680
nos lo ha pedido.

35
00:02:11,680 --> 00:02:13,360
Aquí esa parte de diseño ya está.

36
00:02:13,360 --> 00:02:14,800
Bueno, pues mejor.

37
00:02:14,800 --> 00:02:20,040
Entonces, habíamos hecho, la parte que habíamos hecho era,

38
00:02:20,040 --> 00:02:20,540
silencio.

39
00:02:28,840 --> 00:02:33,840
A ver, Moisés y María, callaos.

40
00:02:33,840 --> 00:02:37,600
Si queréis aprender a hablar por señas, pues hablad por señas.

41
00:02:37,600 --> 00:02:42,760
Pero con algo que no haga ruido, ¿vale?

42
00:02:42,760 --> 00:02:44,680
Porque si no, os cambio directamente.

43
00:02:48,880 --> 00:02:51,920
Vale, a ver, entonces, las clases que habíamos hecho.

44
00:02:51,920 --> 00:02:55,040
Habíamos hecho la entidad aplicación,

45
00:02:55,040 --> 00:02:57,520
que representa a una posible aplicación,

46
00:02:57,520 --> 00:03:00,960
una posible aplicación que se caracterizaba solo por su nombre,

47
00:03:00,960 --> 00:03:03,520
su versión y su tamaño en gigas.

48
00:03:03,520 --> 00:03:06,560
Ya está, una posible aplicación.

49
00:03:06,560 --> 00:03:11,280
Entonces, por defecto, en una entidad siempre hacíamos

50
00:03:11,280 --> 00:03:17,920
constructores con y sin parámetros,

51
00:03:17,920 --> 00:03:20,320
getter y setter, porque las propiedades las hacemos

52
00:03:20,320 --> 00:03:24,040
privadas y accedemos a ellas desde fuera de la clase con los

53
00:03:24,040 --> 00:03:27,400
get para leer y con los set para escribir.

54
00:03:27,400 --> 00:03:30,400
Y luego simplemente un método, simplemente un método que

55
00:03:30,400 --> 00:03:33,480
simulaba que la aplicación se estaba ejecutando, nada más.

56
00:03:33,480 --> 00:03:36,320
Simulaba que esa aplicación se estaba ejecutando,

57
00:03:36,320 --> 00:03:38,240
nada más que eso.

58
00:03:38,240 --> 00:03:41,240
Entonces, ese método no es estático,

59
00:03:41,240 --> 00:03:45,000
porque ese método simula que es una aplicación concreto la que

60
00:03:45,000 --> 00:03:47,240
se ejecuta, una.

61
00:03:47,240 --> 00:03:50,240
Entonces, el método depende de esa aplicación y, por tanto,

62
00:03:50,240 --> 00:03:52,360
no tiene sentido que sea estático.

63
00:03:52,360 --> 00:03:57,120
Por eso incluíamos aquí nombre, para forzar a que no fuera

64
00:03:57,120 --> 00:03:58,480
estático, ¿verdad?

65
00:03:58,480 --> 00:04:01,120
Desde el momento en que depende de una propiedad de la clase,

66
00:04:01,120 --> 00:04:02,800
ya es imposible que lo sea.

67
00:04:02,800 --> 00:04:06,320
Bueno, pues nada, ese método no es tontería para simular que

68
00:04:06,320 --> 00:04:08,080
una aplicación se está ejecutando.

69
00:04:08,080 --> 00:04:11,600
Nada más que eso, ¿vale?

70
00:04:11,600 --> 00:04:14,520
Y luego teníamos el almacén de aplicaciones.

71
00:04:14,520 --> 00:04:18,320
El almacén de aplicaciones tenía un conjunto de aplicaciones de

72
00:04:18,320 --> 00:04:23,320
esas anteriores, un conjunto de esas, ¿vale?

73
00:04:23,320 --> 00:04:24,720
Un conjunto de esas aplicaciones.

74
00:04:24,720 --> 00:04:27,760
Entonces, un conjunto de esas aplicaciones tiene que ser una

75
00:04:27,760 --> 00:04:31,480
estructura de datos que represente mucho de algo que

76
00:04:31,480 --> 00:04:34,000
ahora mismo solo conocemos el array.

77
00:04:34,000 --> 00:04:37,440
Pues ya está, un array, muchas de esas.

78
00:04:37,440 --> 00:04:49,600
Con sus constructores, su get, su set.

79
00:04:49,600 --> 00:04:52,240
Y el constructor nos dijeron, a ver,

80
00:04:52,240 --> 00:04:56,040
haz un constructor que en lugar de recibir el array como tal,

81
00:04:56,040 --> 00:04:57,880
reciba una cadena.

82
00:04:57,880 --> 00:05:00,600
Reciba una cadena que contenga todos los datos de las

83
00:05:00,600 --> 00:05:02,240
aplicaciones, ¿verdad?

84
00:05:02,240 --> 00:05:04,520
Recibía una cadena de este estilo.

85
00:05:04,520 --> 00:05:05,840
Recibía una cadena.

86
00:05:05,840 --> 00:05:10,760
Y dentro de esa cadena estaban los datos de todas las

87
00:05:10,760 --> 00:05:14,800
aplicaciones con las que íbamos a construir ese almacén.

88
00:05:14,800 --> 00:05:19,520
Bueno, pues, entonces, en este constructor tuvimos que

89
00:05:19,520 --> 00:05:23,720
indagar, averiguar métodos de la clase string que nos

90
00:05:23,720 --> 00:05:29,280
facilitaran la tarea de romper en cachitos este string y con

91
00:05:29,280 --> 00:05:32,280
cada cachito instanciar un objeto aplicación,

92
00:05:32,280 --> 00:05:35,520
meterlo en el array, etcétera, ¿vale?

93
00:05:35,520 --> 00:05:38,200
Bueno, pues, para eso descubrimos que teníamos un

94
00:05:38,200 --> 00:05:42,480
método split que nos era muy útil para romper un string en

95
00:05:42,480 --> 00:05:45,840
trocitos separados por un separador,

96
00:05:45,840 --> 00:05:48,800
el separador que uno le quisiera dar, este aquí,

97
00:05:48,800 --> 00:05:50,480
luego este, etcétera.

98
00:05:50,480 --> 00:05:53,840
Y de esa manera instanciábamos una aplicación y la guardábamos

99
00:05:53,840 --> 00:05:55,400
en el almacén.

100
00:05:55,400 --> 00:06:00,520
Entonces, nuestro constructor era un constructor hecho a medida

101
00:06:00,520 --> 00:06:02,000
de lo que nos habían pedido.

102
00:06:02,000 --> 00:06:06,120
Un constructor que recibió una cadena y rellenaba el array de

103
00:06:06,120 --> 00:06:12,160
arriba, rellenaba el array de arriba con las aplicaciones

104
00:06:12,160 --> 00:06:14,840
cuya información estaba recogida en esa cadena.

105
00:06:14,840 --> 00:06:17,560
Ya está, un constructor, pues, bueno, raro.

106
00:06:17,560 --> 00:06:20,280
Y luego ya esta aplicación nos dijeron, bueno,

107
00:06:20,280 --> 00:06:21,920
hazle más métodos.

108
00:06:21,920 --> 00:06:26,080
Hazle el método install, install.

109
00:06:26,080 --> 00:06:28,600
Este método recibía un nombre de aplicación,

110
00:06:28,600 --> 00:06:31,120
recibía un nombre, por eso recibía un string,

111
00:06:31,120 --> 00:06:33,080
y buscaban el almacén de arriba,

112
00:06:33,080 --> 00:06:36,880
buscaban el almacén, la aplicación cuyo nombre fuera

113
00:06:36,880 --> 00:06:37,600
igual.

114
00:06:37,600 --> 00:06:43,080
Y una vez que la encontraba, creaba un objeto distinto,

115
00:06:43,080 --> 00:06:47,280
pero cuyas propiedades eran idénticas de este, ¿vale?

116
00:06:47,280 --> 00:06:51,360
O sea, creaba un objeto diferente apuntado por la

117
00:06:51,360 --> 00:06:52,960
dirección a, ¿verdad?

118
00:06:52,960 --> 00:06:54,120
Creaba un objeto distinto.

119
00:06:54,120 --> 00:06:55,920
Desde el momento en que se hace un new,

120
00:06:55,920 --> 00:06:59,520
el new significa aparece un espacio para un objeto en

121
00:06:59,520 --> 00:07:00,040
memoria.

122
00:07:00,040 --> 00:07:03,280
Eso significa el new, aparece un espacio nuevo.

123
00:07:03,280 --> 00:07:06,200
Ese espacio tiene que estar apuntado por algún sitio.

124
00:07:06,200 --> 00:07:07,640
¿Por dónde está apuntado?

125
00:07:07,640 --> 00:07:11,680
Pues, allá donde asignemos el resultado del new, ¿verdad?

126
00:07:11,680 --> 00:07:13,160
Así funciona esto.

127
00:07:13,160 --> 00:07:18,080
El new significa crea espacio para un objeto de esta clase

128
00:07:18,080 --> 00:07:21,640
y la dirección devuélvemela y guárdala en la referencia que

129
00:07:21,640 --> 00:07:23,200
yo ponga aquí.

130
00:07:23,200 --> 00:07:24,240
Eso es como funciona, ¿no?

131
00:07:24,240 --> 00:07:26,040
La instanciación de un objeto.

132
00:07:26,040 --> 00:07:29,000
Bueno, pues, efectivamente hacíamos un objeto nuevo,

133
00:07:29,000 --> 00:07:32,800
un espacio de memoria nuevo, pero para que fuera una copia

134
00:07:32,800 --> 00:07:35,520
del otro, copiábamos las propiedades.

135
00:07:35,520 --> 00:07:39,880
Las propiedades del objeto que habíamos creado apuntado por a,

136
00:07:39,880 --> 00:07:43,000
pues, las copiábamos de las del almacén.

137
00:07:43,000 --> 00:07:47,040
Entonces, hacíamos una copia, dos objetos distintos,

138
00:07:47,040 --> 00:07:51,360
pero con las mismas propiedades, pero objetos distintos.

139
00:07:51,360 --> 00:07:54,560
Entonces, eso es lo que se llama hacer un clon, en realidad.

140
00:07:54,560 --> 00:07:56,560
Entonces, tú haces un clon y desde el momento en que son

141
00:07:56,560 --> 00:07:59,360
dos objetos distintos, lógicamente,

142
00:07:59,360 --> 00:08:02,440
cuando tú cambies los datos de uno,

143
00:08:02,440 --> 00:08:05,480
las del otro no se van a cambiar porque son dos objetos distintos.

144
00:08:05,480 --> 00:08:09,040
Son dos objetos diferentes.

145
00:08:09,040 --> 00:08:11,480
Aquí lo que dijimos es, sin embargo,

146
00:08:11,480 --> 00:08:15,400
si hacíamos esto, declarábamos una referencia a,

147
00:08:15,400 --> 00:08:18,840
declaramos una referencia y a esa referencia le dábamos la

148
00:08:18,840 --> 00:08:22,920
referencia esta, ahí no había dos objetos distintos.

149
00:08:22,920 --> 00:08:29,920
Ahí había un único objeto apuntado por dos variables distintas,

150
00:08:29,920 --> 00:08:32,840
por la variable a y por esta variable.

151
00:08:32,840 --> 00:08:36,360
Pero era un único objeto, un único objeto apuntado por dos

152
00:08:36,360 --> 00:08:38,320
referencias, por a y por esta.

153
00:08:38,320 --> 00:08:40,280
Entonces, ahí como hay un único objeto,

154
00:08:40,280 --> 00:08:43,320
me da igual acceder a ese objeto a partir de aquí que a partir de aquí,

155
00:08:43,320 --> 00:08:44,400
porque estoy haciendo el mismo.

156
00:08:44,400 --> 00:08:47,960
Si cambio las propiedades del objeto apuntado por este,

157
00:08:47,960 --> 00:08:51,080
estoy cambiando también las propiedades del objeto apuntado por este,

158
00:08:51,120 --> 00:08:53,120
porque están apuntando al mismo.

159
00:08:53,120 --> 00:08:56,240
Entonces, lógicamente, el funcionamiento de esto y el

160
00:08:56,240 --> 00:08:59,120
funcionamiento de esto es completamente distinto, ¿vale?

161
00:08:59,120 --> 00:09:04,480
Aquí hay dos direcciones que llevan al mismo objeto y aquí hay dos

162
00:09:04,480 --> 00:09:09,840
direcciones que llevan a distintos objetos, ¿vale?

163
00:09:09,840 --> 00:09:13,720
Bueno, es importante entender eso.

164
00:09:13,720 --> 00:09:14,760
¿En qué situaciones?

165
00:09:14,760 --> 00:09:17,320
En una aplicación necesita trabajar con copias,

166
00:09:17,320 --> 00:09:20,560
necesita trabajar con el mismo objeto porque tiene efectos distintos,

167
00:09:21,560 --> 00:09:23,200
bueno, pues, el método de instalo hacía eso.

168
00:09:23,200 --> 00:09:27,840
Sacaba una copia, un objeto copia y lo devolvía como valor de retorno,

169
00:09:27,840 --> 00:09:30,480
lo devolvía ahí, ¿vale?

170
00:09:30,480 --> 00:09:31,480
Ala, ya está.

171
00:09:31,480 --> 00:09:35,160
Y luego había otro método que decía también para este almacén de

172
00:09:35,160 --> 00:09:44,560
aplicaciones, silencio, había otro método para ese almacén de

173
00:09:44,560 --> 00:09:48,760
aplicaciones que te decía, yo te doy un objeto app y mételo en el

174
00:09:48,760 --> 00:09:49,760
array.

175
00:09:49,760 --> 00:09:52,160
Pues, esto sí que es la historia de siempre,

176
00:09:52,160 --> 00:09:53,840
la historia de toda la vida, ¿vale?

177
00:09:53,840 --> 00:09:54,840
Mételo en el array.

178
00:09:54,840 --> 00:09:56,920
Pues, ala, ahí metido, se acabó.

179
00:09:56,920 --> 00:10:02,600
Entonces, bueno, este main lo hicimos aquí para probar lo del

180
00:10:02,600 --> 00:10:06,880
split, a ver si nos había funcionado, ¿vale?

181
00:10:06,880 --> 00:10:10,840
Y también, también lo hice ahí para que entendierais que un main

182
00:10:10,840 --> 00:10:13,440
en realidad es un método que uno puede poner en cualquier lado

183
00:10:13,440 --> 00:10:14,920
porque es un método más.

184
00:10:14,920 --> 00:10:18,280
Un main es un método más, un método más que uno pone en la

185
00:10:18,320 --> 00:10:19,800
clase que quiera.

186
00:10:19,800 --> 00:10:22,200
Pero, claro, si uno pone en una clase un método main, ¿qué ocurre?

187
00:10:22,200 --> 00:10:27,600
Que automáticamente esa clase se convierte en punto de arranque de

188
00:10:27,600 --> 00:10:29,760
una aplicación porque eso es el método main.

189
00:10:29,760 --> 00:10:32,840
El método main es el punto de arranque de una aplicación.

190
00:10:32,840 --> 00:10:36,200
Cuando a una máquina virtual la llamamos para que ejecute una

191
00:10:36,200 --> 00:10:39,600
aplicación, ella busca el main.

192
00:10:39,600 --> 00:10:42,720
Entonces, aquí pusimos un main para poder ejecutar esa clase,

193
00:10:42,720 --> 00:10:45,200
para poder ejecutarla y probar esto.

194
00:10:45,200 --> 00:10:48,440
Y esta clase en particular lo que hacía era instanciar este

195
00:10:48,440 --> 00:10:52,600
objeto, llamar al constructor para ver si el constructor hacía

196
00:10:52,600 --> 00:10:56,280
lo que queríamos nosotros, que era, pues,

197
00:10:56,280 --> 00:10:58,320
hacer el split del patatín.

198
00:10:58,320 --> 00:10:59,600
Y comprobamos que sí que lo hacía,

199
00:10:59,600 --> 00:11:01,280
que eso estaba bien hecho, etcétera.

200
00:11:01,280 --> 00:11:05,040
Entonces, este main aquí ahora mismo, pues, bueno,

201
00:11:05,040 --> 00:11:06,960
nos vino muy bien para hacer las pruebas,

202
00:11:06,960 --> 00:11:14,280
pero podemos dejarlo comentado para no liar porque luego esta

203
00:11:15,120 --> 00:11:18,600
aplicación ya tendrá su main aparte en otra clase,

204
00:11:18,600 --> 00:11:20,480
en otra clase en la que cree el almacén,

205
00:11:20,480 --> 00:11:22,760
cree las aplicaciones, etcétera.

206
00:11:22,760 --> 00:11:25,280
Bueno, pues, ya teníamos estas 2 clases hechas,

207
00:11:25,280 --> 00:11:27,280
una única aplicación y un almacén.

208
00:11:30,120 --> 00:11:31,040
Bueno, y nos faltaban, ¿no?

209
00:11:31,040 --> 00:11:32,160
Nos faltaban métodos.

210
00:11:32,160 --> 00:11:35,680
Habíamos hecho el de App Store, habíamos hecho el install,

211
00:11:35,680 --> 00:11:38,240
el incorporar, que me lo inventé yo, pues,

212
00:11:38,240 --> 00:11:41,680
para meter una aplicación, cambiar versión,

213
00:11:41,680 --> 00:11:47,000
prestar aplicaciones y comprobar actualización, ¿vale?

214
00:11:47,000 --> 00:11:48,800
Moisés, por fa, siéntate aquí delante.

215
00:11:54,800 --> 00:11:57,760
Y Andrés, tú ponte ahí, en ese hueco que hay ahí, estupendo.

216
00:12:03,920 --> 00:12:08,360
Vale, estos 3 métodos nos faltan de App Store.

217
00:12:08,360 --> 00:12:13,120
Luego nos falta la clase móvil, que representa a un móvil.

218
00:12:13,120 --> 00:12:15,040
Y luego ya nos falta el main.

219
00:12:15,040 --> 00:12:17,600
Este es el main para hacer las pruebas, ¿vale?

220
00:12:17,600 --> 00:12:18,100
Ya está.

221
00:12:24,240 --> 00:12:27,880
Venga, pues, vamos con cambiar versión.

222
00:12:27,880 --> 00:12:29,760
Parece la más sencilla.

223
00:12:29,760 --> 00:12:30,320
Vamos a ver.

224
00:12:33,920 --> 00:12:35,840
Venga, a ver, cambiar versión.

225
00:12:39,360 --> 00:12:45,080
Sí, incorporar, este era, por si,

226
00:12:45,080 --> 00:12:48,720
se supone que el almacén de aplicaciones se crea con el

227
00:12:48,720 --> 00:12:52,480
constructor a partir de la cadena y se crea.

228
00:12:52,480 --> 00:12:55,080
Entonces, yo había metido ese método por si a posteriori,

229
00:12:55,080 --> 00:12:57,800
una vez que el objeto App Store está creado,

230
00:12:57,800 --> 00:12:59,520
por si quisieras meter otra más.

231
00:12:59,520 --> 00:13:02,760
Si quieres meter otra más, pues, necesitas un método para meterlo.

232
00:13:08,360 --> 00:13:08,860
Vale.

233
00:13:14,240 --> 00:13:15,840
Vale.

234
00:13:15,840 --> 00:13:17,360
Venga, sí que tardas tú.

235
00:13:21,640 --> 00:13:29,000
Bueno, a ver, estábamos con el método este, cambiar versión.

236
00:13:29,000 --> 00:13:30,080
Vale, cambiar versión.

237
00:13:30,080 --> 00:13:39,680
Si se va a llamar desde fuera, que es la idea,

238
00:13:39,680 --> 00:13:42,640
porque esta es la funcionalidad que ofrece App Store hacia el

239
00:13:42,640 --> 00:13:43,760
exterior.

240
00:13:43,760 --> 00:13:47,400
La clase App Store ofrece una funcionalidad al exterior de

241
00:13:47,400 --> 00:13:50,200
cambiar versiones.

242
00:13:50,200 --> 00:13:52,480
Venga, ahí, por ejemplo.

243
00:13:52,480 --> 00:13:56,000
Cambiar versiones, incorporar apps, lo que sea.

244
00:13:56,000 --> 00:13:58,200
Entonces, las ofrece al exterior.

245
00:13:58,200 --> 00:14:02,200
Entonces, el método es público.

246
00:14:02,200 --> 00:14:04,880
Y ahora ya, pues, cambiar versión,

247
00:14:04,880 --> 00:14:07,800
el nombre nos lo han hecho, pues, no lo podemos elegir.

248
00:14:14,400 --> 00:14:20,440
Y dice, este método recibe como parámetros una cadena y un

249
00:14:20,440 --> 00:14:20,940
entero.

250
00:14:20,940 --> 00:14:31,460
Una cadena, que se supone que es el nombre de una aplicación,

251
00:14:31,460 --> 00:14:38,140
y un entero, que se supone que es una versión.

252
00:14:38,140 --> 00:14:38,640
¿Vale?

253
00:14:38,640 --> 00:14:40,980
¿Qué tiene que hacer?

254
00:14:40,980 --> 00:14:47,580
Pues, entonces, cambia la versión de la aplicación dentro

255
00:14:47,620 --> 00:14:55,460
del almacén de la RAI, que se llame así, la cambia a esta.

256
00:14:55,460 --> 00:14:55,960
¿Vale?

257
00:14:55,960 --> 00:14:57,380
Cambia la versión de la aplicación,

258
00:14:57,380 --> 00:15:00,220
que se llame así, la cambia a esta.

259
00:15:00,220 --> 00:15:05,620
Entonces, pregunta, ¿qué hago yo?

260
00:15:05,620 --> 00:15:08,220
¿Qué pongo aquí?

261
00:15:08,220 --> 00:15:09,460
Dictadme, ¿qué pongo?

262
00:15:13,300 --> 00:15:14,300
Void, sí.

263
00:15:14,300 --> 00:15:14,780
¿Vale?

264
00:15:14,780 --> 00:15:15,700
Pongo void.

265
00:15:15,740 --> 00:15:17,660
Porque este método, el efecto que tiene,

266
00:15:17,660 --> 00:15:21,620
el efecto que tiene simplemente es sobre la propiedad de la

267
00:15:21,620 --> 00:15:22,420
clase.

268
00:15:22,420 --> 00:15:25,340
Recordad que estamos en esta clase cuya propiedad es esta.

269
00:15:25,340 --> 00:15:25,840
¿Vale?

270
00:15:25,840 --> 00:15:27,100
Tiene este efecto.

271
00:15:27,100 --> 00:15:28,580
¿Vale?

272
00:15:28,580 --> 00:15:30,700
Bueno, pues, entonces, no tiene que devolver nada.

273
00:15:30,700 --> 00:15:32,340
Otra cosa es que me dijeran, oye,

274
00:15:32,340 --> 00:15:35,900
que devuelva un boolean, que hay veces es un método habitual,

275
00:15:35,900 --> 00:15:40,820
que sea true o false, si lo pudo hacer o no lo pudo hacer.

276
00:15:40,820 --> 00:15:43,940
Hay veces que cuando un método no hace falta que devuelva

277
00:15:43,980 --> 00:15:47,140
nada, lo que se le hace es que devuelva un boolean que te

278
00:15:47,140 --> 00:15:48,660
sirva como control.

279
00:15:48,660 --> 00:15:51,140
Si lo ha podido hacer correctamente, te devuelve true.

280
00:15:51,140 --> 00:15:53,500
Si no lo ha podido hacer correctamente, te devuelve false.

281
00:15:53,500 --> 00:15:55,820
Pero, claro, eso sobre todo tiene utilidad si lo que hace el

282
00:15:55,820 --> 00:15:58,220
método implica llamar a cosas raras,

283
00:15:58,220 --> 00:15:59,460
conectarse a una base de datos.

284
00:15:59,460 --> 00:16:00,860
Porque ahí, que lo haga bien o mal,

285
00:16:00,860 --> 00:16:04,140
va a depender de cosas que se escapan a tu control.

286
00:16:04,140 --> 00:16:07,660
Aquí este método, lo único que hace es acceder a un array que

287
00:16:07,660 --> 00:16:10,580
está dentro de la clase, que va a funcionar mal.

288
00:16:10,580 --> 00:16:11,980
No hay nada que pueda funcionar mal.

289
00:16:11,980 --> 00:16:14,020
Entonces, no tiene sentido incorporar un boolean de

290
00:16:14,020 --> 00:16:15,100
control, ¿vale?

291
00:16:15,100 --> 00:16:22,660
Pero es un patrón, es un patrón de programar que se usa mucho.

292
00:16:22,660 --> 00:16:24,980
Devolver un boolean de control que te diga si se ha hecho bien

293
00:16:24,980 --> 00:16:25,500
o mal.

294
00:16:25,500 --> 00:16:28,460
Pero nosotros por ahora ni lo incorporamos.

295
00:16:28,460 --> 00:16:30,260
Vale, pues, venga.

296
00:16:30,260 --> 00:16:31,980
Cambiar versión.

297
00:16:31,980 --> 00:16:32,860
Ala, pues, venga.

298
00:16:37,340 --> 00:16:38,300
Vale, pues, nada.

299
00:16:38,340 --> 00:16:40,940
Nosotros este método changeVersion,

300
00:16:40,940 --> 00:16:42,140
¿quién lo va a llamar?

301
00:16:42,140 --> 00:16:45,620
Lo va a llamar un objeto de esta clase,

302
00:16:45,620 --> 00:16:48,020
un objeto de esta clase porque ese método está en esa clase,

303
00:16:48,020 --> 00:16:49,580
obviamente.

304
00:16:49,580 --> 00:16:53,020
Y lo va a llamar teniendo dentro su almacén de aplicaciones,

305
00:16:53,020 --> 00:16:56,100
claro, obviamente, porque esa es una propiedad de la clase.

306
00:16:56,100 --> 00:16:58,300
Vale, pues, entonces, ¿qué tendrá que hacer este método?

307
00:16:58,300 --> 00:17:02,500
Buscar en ese array la aplicación que se llame así.

308
00:17:02,500 --> 00:17:05,460
Y a la que se llame así cambia la versión, ¿verdad?

309
00:17:05,460 --> 00:17:06,700
Es lo que tiene que hacer.

310
00:17:06,700 --> 00:17:08,980
Bueno, pues, buscar en el array, pues,

311
00:17:08,980 --> 00:17:10,140
ya sabemos de toda la vida.

312
00:17:10,140 --> 00:17:13,620
Vamos a buscar en el array.

313
00:17:13,620 --> 00:17:18,420
Siempre vamos a buscar en ese array que se llama apps,

314
00:17:18,420 --> 00:17:20,540
creo que se llamaba, ¿no?

315
00:17:20,540 --> 00:17:24,700
Igual no se llama así porque no me está ofreciendo nada.

316
00:17:24,700 --> 00:17:25,540
Se llama store.

317
00:17:25,540 --> 00:17:28,260
Vale.

318
00:17:28,260 --> 00:17:35,180
En ese array que se llama así vamos a buscar la aplicación

319
00:17:35,180 --> 00:17:37,940
cuyo nombre sea igual que este.

320
00:17:37,940 --> 00:17:40,860
Es recorrer un array que hemos recorrido toda la vida.

321
00:17:40,860 --> 00:17:43,060
Y en ese array, ¿qué queremos hacer?

322
00:17:43,060 --> 00:17:46,620
Pues, vamos a aplicación por aplicación dentro de ese array.

323
00:17:46,620 --> 00:17:48,700
Aplicación por aplicación.

324
00:17:48,700 --> 00:17:54,340
Oye, si esta aplicación en la que estoy resulta que su nombre,

325
00:17:54,340 --> 00:17:56,860
el nombre lo sacó con get, claro,

326
00:17:56,860 --> 00:18:02,020
que su nombre es igual que el de búsqueda que me han dado.

327
00:18:02,020 --> 00:18:03,620
Ah, vale, pues, ya estoy.

328
00:18:03,620 --> 00:18:06,860
Esta es la aplicación de la cual quiero cambiar la versión.

329
00:18:06,860 --> 00:18:08,460
Es esta, ya la he encontrado.

330
00:18:08,460 --> 00:18:10,660
Es la búsqueda del array de siempre.

331
00:18:10,660 --> 00:18:13,700
Y en cada posición miro a ver si cumple la condición de

332
00:18:13,700 --> 00:18:14,300
búsqueda.

333
00:18:14,300 --> 00:18:15,180
¿Es igual que el nombre?

334
00:18:15,180 --> 00:18:15,680
Sí.

335
00:18:15,680 --> 00:18:17,180
Ah, justo, ya la encontré.

336
00:18:17,180 --> 00:18:19,260
Ahora, ¿qué hago con ella una vez encontrada?

337
00:18:19,260 --> 00:18:20,460
Cambiarle la versión.

338
00:18:20,460 --> 00:18:22,300
Pues, a la, le cambio la versión.

339
00:18:28,540 --> 00:18:29,020
¿A cuál?

340
00:18:29,020 --> 00:18:30,780
A la que me han dado como parámetro y listo.

341
00:18:30,780 --> 00:18:31,260
¿Vale?

342
00:18:31,260 --> 00:18:33,380
Y ya está, ya acaba el método.

343
00:18:33,380 --> 00:18:38,220
No había falta buscarlo también por la versión.

344
00:18:38,220 --> 00:18:42,380
No, el método te dice, la aplicación que se llame así,

345
00:18:42,380 --> 00:18:46,060
a esa le pones como nueva versión la que yo te he dado,

346
00:18:46,060 --> 00:18:47,380
sobreescribiendo la otra.

347
00:18:47,380 --> 00:18:49,980
Entonces, tu parámetro de búsqueda es el nombre.

348
00:18:49,980 --> 00:18:51,660
Por ese es por el que buscas.

349
00:18:51,660 --> 00:18:54,740
Este es el parámetro por el que buscas.

350
00:18:54,740 --> 00:18:57,540
Entonces, cuando has encontrado la aplicación cuyo nombre es

351
00:18:57,540 --> 00:18:59,180
ese, ya la tienes.

352
00:18:59,180 --> 00:19:00,500
Tu búsqueda ya ha terminado.

353
00:19:00,500 --> 00:19:03,140
Vale, ¿ahora qué haces con esa aplicación?

354
00:19:03,140 --> 00:19:06,020
Lo que te han dicho que hagas, que en este caso es,

355
00:19:06,020 --> 00:19:08,940
ponerle como versión la que te estoy dando,

356
00:19:08,940 --> 00:19:11,540
pisando la que tuviera de antes, claro.

357
00:19:11,540 --> 00:19:13,900
¿Vale?

358
00:19:13,900 --> 00:19:16,700
Bueno, pues ya está, este método ya estaría.

359
00:19:16,700 --> 00:19:21,620
A ver, aquí pasa lo de siempre, que imaginaos que el almacén de

360
00:19:21,620 --> 00:19:27,100
aplicaciones tiene 50,000, yo qué sé, 50,000.

361
00:19:27,100 --> 00:19:29,220
Entonces, y la encuentra a la primera,

362
00:19:29,220 --> 00:19:31,380
a la primera la ha encontrado.

363
00:19:31,380 --> 00:19:36,620
Pues, hombre, se está 49,999 iteraciones que ya le sobran,

364
00:19:36,620 --> 00:19:37,100
¿vale?

365
00:19:37,100 --> 00:19:39,660
Porque ya la ha encontrado, que ya le sobran.

366
00:19:39,660 --> 00:19:43,820
Entonces, hombre, no estaría mal si hacemos una forma de que,

367
00:19:43,820 --> 00:19:47,700
para que este bucle pare, para que este for deje de ejecutarse

368
00:19:47,700 --> 00:19:52,300
una vez que este if ya se cumplió, ¿verdad?

369
00:19:52,300 --> 00:19:55,740
Que no pasa nada, lo podemos dejar así, no ocurre nada.

370
00:19:55,740 --> 00:19:58,180
Pero, bueno, si lo dejamos de ejecutar una vez que hemos

371
00:19:58,180 --> 00:20:00,180
encontrado la aplicación.

372
00:20:00,180 --> 00:20:03,020
Entonces, aquí viene la discusión de siempre.

373
00:20:03,020 --> 00:20:05,780
Aquí viene la discusión de siempre.

374
00:20:05,780 --> 00:20:16,060
Sí, el método feo o el método bonito, ¿vale?

375
00:20:16,060 --> 00:20:17,420
Esa es la discusión de siempre.

376
00:20:23,820 --> 00:20:27,060
¿Cuál es el método feo?

377
00:20:27,060 --> 00:20:31,620
Para hacer eso que digo, una vez que hemos encontrado la

378
00:20:31,620 --> 00:20:34,260
aplicación que se llama así y, por tanto,

379
00:20:34,260 --> 00:20:37,540
ha entrado en el if, ¿cómo conseguimos que el bucle ya no

380
00:20:37,540 --> 00:20:39,020
se ejecute más veces?

381
00:20:39,020 --> 00:20:40,900
Que sea esta la última y poder.

382
00:20:40,900 --> 00:20:43,500
El método feo es el break, efectivamente.

383
00:20:43,500 --> 00:20:47,580
Entonces, este es el método feo, ¿vale?

384
00:20:47,580 --> 00:20:50,860
Pues, ya está, el método feo salió, ¿vale?

385
00:20:50,860 --> 00:20:53,340
O sea, aquí estamos hablando de un bucle for que tiene una

386
00:20:53,340 --> 00:20:54,540
línea.

387
00:20:54,540 --> 00:20:57,460
Entonces, hombre, el que vea este código, pues, hombre,

388
00:20:57,460 --> 00:20:59,300
más o menos va a entender.

389
00:20:59,300 --> 00:21:02,660
Pero recordad que, porque es feo el break y porque en algunos

390
00:21:02,660 --> 00:21:04,140
lenguajes de programación, de hecho,

391
00:21:04,140 --> 00:21:07,900
está incluso prohibida como sentencia eliminada,

392
00:21:07,900 --> 00:21:12,180
porque dificulta la legibilidad del código.

393
00:21:12,180 --> 00:21:14,660
Break no significa nada, break en sí mismo no tiene

394
00:21:14,660 --> 00:21:15,980
información.

395
00:21:15,980 --> 00:21:19,980
No te da la razón de por qué has parado, no te la da.

396
00:21:19,980 --> 00:21:22,220
Y eso es feo, no te la está diciendo.

397
00:21:22,220 --> 00:21:25,700
Entonces, nosotros aquí lo vemos porque el break está

398
00:21:25,700 --> 00:21:28,140
pegadito al if, está juntito.

399
00:21:28,140 --> 00:21:31,500
Entonces, lo vemos, ah, vale, va a salir porque ya lo encontró.

400
00:21:31,500 --> 00:21:33,820
Entonces, queremos salir cuando lo encuentre.

401
00:21:33,820 --> 00:21:36,340
Pero es que está muy pegadito, la razón por la que salimos y

402
00:21:36,340 --> 00:21:37,500
el break están juntos.

403
00:21:37,500 --> 00:21:40,420
Entonces, ahí la legibilidad, bueno, más o menos se ve.

404
00:21:40,420 --> 00:21:43,980
Pero en otras situaciones, tú ves ahí un break plantado y

405
00:21:43,980 --> 00:21:48,060
tienes que irte 300 líneas más arriba para entender por qué le

406
00:21:48,060 --> 00:21:49,340
ha dado la gana salir.

407
00:21:49,340 --> 00:21:50,420
Y esa no es la idea.

408
00:21:50,420 --> 00:21:52,860
Eso hace que el código no sea nada legible.

409
00:21:52,860 --> 00:21:56,060
Si no es legible, es difícilmente modificable.

410
00:21:56,060 --> 00:21:59,140
Y un código que no es actualizable o modificable,

411
00:21:59,140 --> 00:22:00,860
se queda sin tiempo de vida.

412
00:22:00,860 --> 00:22:05,340
Su tiempo de vida se desaparece.

413
00:22:05,340 --> 00:22:07,100
Entonces, no vale para nada.

414
00:22:07,100 --> 00:22:09,540
Entonces, por eso es una sentencia fea,

415
00:22:09,540 --> 00:22:12,340
desagradable a la vista.

416
00:22:12,340 --> 00:22:16,260
Lo normal es salir de un for incorporándolo aquí arriba en

417
00:22:16,260 --> 00:22:17,620
la condición.

418
00:22:17,620 --> 00:22:21,300
Y decir, yo no he llegado al final.

419
00:22:21,300 --> 00:22:23,420
O no he encontrado no sé qué.

420
00:22:23,420 --> 00:22:26,260
Y para eso, pues, hacemos un boolean que se ha encontrado,

421
00:22:26,260 --> 00:22:27,540
que lo cambiemos aquí.

422
00:22:27,540 --> 00:22:31,100
Pongamos, no he encontrado aplicación.

423
00:22:31,100 --> 00:22:33,140
Eso es más bonito.

424
00:22:33,140 --> 00:22:34,140
Eso sería más bonito.

425
00:22:37,420 --> 00:22:38,020
Algo así.

426
00:22:47,700 --> 00:22:52,020
App encontrada.

427
00:22:52,020 --> 00:22:53,540
Inicialmente es falso.

428
00:22:53,540 --> 00:22:55,260
No está encontrada.

429
00:22:55,260 --> 00:22:57,740
Y ahora, cuando ya la hemos encontrado,

430
00:22:57,740 --> 00:23:01,260
voy a dejar aquí el break, no borrado, pero comentado.

431
00:23:01,260 --> 00:23:03,740
Cuando ya la hemos encontrado, avisamos,

432
00:23:03,740 --> 00:23:09,060
app encontrada igual a true.

433
00:23:09,060 --> 00:23:10,540
Ya la hemos encontrado.

434
00:23:10,540 --> 00:23:11,300
Está encontrada.

435
00:23:11,300 --> 00:23:11,820
Fenomenal.

436
00:23:11,820 --> 00:23:14,100
Esta es la estructura nuestra de toda la vida, ¿no?

437
00:23:14,100 --> 00:23:17,580
Con la que tenemos que familiarizarnos.

438
00:23:17,580 --> 00:23:19,820
Yo hago un recorrido para buscar algo.

439
00:23:19,820 --> 00:23:21,980
De partida asumo que no está.

440
00:23:21,980 --> 00:23:24,980
Cuando lo he encontrado, ya puedo cambiar la conclusión.

441
00:23:24,980 --> 00:23:25,980
Ya puedo cambiarla.

442
00:23:25,980 --> 00:23:29,740
Y ahora esto lo usamos para muchas cosas.

443
00:23:29,740 --> 00:23:32,180
Lo podemos usar aquí fuera para distinguir si la hemos

444
00:23:32,180 --> 00:23:35,380
encontrado o no, mostrándolo por consola si es que no lo piden.

445
00:23:35,380 --> 00:23:39,020
La podemos usar aquí dentro para forzar que el bucle ya no se

446
00:23:39,020 --> 00:23:39,940
ejecute más.

447
00:23:39,940 --> 00:23:43,420
Podremos usar este boolean para muchas cosas.

448
00:23:43,420 --> 00:23:46,700
Entonces, en particular, podemos usarlo para incorporarlo y

449
00:23:46,780 --> 00:23:49,780
hacer esta condición de aquí un poquito más grandecita.

450
00:23:49,780 --> 00:23:54,700
Y decir, este bucle se va a ejecutar mientras yo no haya

451
00:23:54,700 --> 00:24:03,660
llegado al final y la aplicación no esté encontrada.

452
00:24:03,660 --> 00:24:09,340
A ver si lo, vamos a revisarlo, porque igual lo he escrito mal.

453
00:24:09,340 --> 00:24:13,980
Mientras yo no haya llegado al final y no haya encontrado la

454
00:24:13,980 --> 00:24:17,460
aplicación, entonces sigue.

455
00:24:17,460 --> 00:24:19,540
Es decir, para que el bucle siga,

456
00:24:19,540 --> 00:24:22,420
tienen que darse simultáneamente dos cosas.

457
00:24:22,420 --> 00:24:24,820
Tienen que darse simultáneamente.

458
00:24:24,820 --> 00:24:27,620
No haber terminado con el array, por supuesto,

459
00:24:27,620 --> 00:24:30,140
pero no haber encontrado la aplicación.

460
00:24:30,140 --> 00:24:34,020
Tiene que ser la simultaneidad de dos cosas para que el bucle

461
00:24:34,020 --> 00:24:34,540
siga.

462
00:24:34,540 --> 00:24:36,820
La simultaneidad de dos cosas es el AND.

463
00:24:37,140 --> 00:24:37,620
¿Vale?

464
00:24:37,620 --> 00:24:42,340
¿Si no tiene falta la condición del true?

465
00:24:42,340 --> 00:24:43,380
¿Perdón?

466
00:24:43,380 --> 00:24:46,340
Si sigue, tiene falta el true.

467
00:24:46,340 --> 00:24:47,500
Después de poner el AND.

468
00:24:47,500 --> 00:24:48,580
Esto dices.

469
00:24:48,580 --> 00:24:52,660
Bueno, claro, porque si no, esta condición nunca va a cambiar.

470
00:24:52,660 --> 00:24:55,500
Es decir, con esto yo ya digo, ah, ya la he encontrado.

471
00:24:55,500 --> 00:25:00,180
Y eso va a hacer que el bucle ya deje de ejecutarse.

472
00:25:00,180 --> 00:25:01,820
Es que si yo no pongo esto a true,

473
00:25:01,820 --> 00:25:04,260
esta condición va a ser true toda la vida.

474
00:25:04,260 --> 00:25:06,060
Nunca va a ser falsa.

475
00:25:06,100 --> 00:25:08,940
Este bucle se va a dejar de ejecutar cuando una de las dos

476
00:25:08,940 --> 00:25:10,420
sea falsa, ¿no?

477
00:25:10,420 --> 00:25:13,940
Esta está clara porque ya he terminado.

478
00:25:13,940 --> 00:25:15,700
O sea, el vale es que ya las he entendido.

479
00:25:15,700 --> 00:25:16,380
Ah, vale, vale.

480
00:25:20,660 --> 00:25:24,220
Vale, pues, entonces, cambiar versión, ya está.

481
00:25:24,220 --> 00:25:24,720
Vale.

482
00:25:28,020 --> 00:25:29,260
Listar aplicaciones.

483
00:25:29,260 --> 00:25:31,980
Bueno, esta parece más sencilla.

484
00:25:31,980 --> 00:25:36,780
Bueno, un string que en una única cadena contenga el listado

485
00:25:36,780 --> 00:25:39,460
de todas las apps y su tamaño.

486
00:25:39,460 --> 00:25:43,260
Pues, venga, vamos a hacer listar aplicaciones.

487
00:25:43,260 --> 00:25:44,380
Devuelve un string.

488
00:25:51,540 --> 00:25:52,580
Pública otra vez.

489
00:25:58,940 --> 00:26:01,740
Devuelve, esta sí que devuelve como valor de retorno,

490
00:26:01,820 --> 00:26:03,540
devuelve un string como valor de retorno.

491
00:26:03,540 --> 00:26:04,380
Lo voy a poner ahí.

492
00:26:11,820 --> 00:26:12,320
Vale.

493
00:26:15,900 --> 00:26:18,740
Ala, listado de aplicaciones.

494
00:26:18,740 --> 00:26:21,860
Tiene que construir un string.

495
00:26:21,860 --> 00:26:23,780
Este va a ser mi resultado, ¿verdad?

496
00:26:23,780 --> 00:26:25,220
Tiene que construir un string ahí.

497
00:26:32,740 --> 00:26:36,780
Tiene que construirlo y al final acabar devolviéndolo.

498
00:26:45,460 --> 00:26:47,540
Vale, ¿cómo lo va a construir?

499
00:26:47,540 --> 00:26:50,900
Concatenando sobre él los datos de las aplicaciones que hay

500
00:26:50,900 --> 00:26:51,860
aquí.

501
00:26:51,860 --> 00:26:54,100
Por eso no se le pasa nada como parámetro.

502
00:26:54,100 --> 00:26:55,660
Por eso no se le pasa nada.

503
00:26:55,660 --> 00:26:58,060
Porque todos los datos que necesita para trabajar,

504
00:26:58,060 --> 00:27:01,460
todos los que necesita, están aquí arriba.

505
00:27:01,460 --> 00:27:04,380
Directamente en una propiedad de la clase.

506
00:27:04,380 --> 00:27:05,820
Por eso no se le pasa nada.

507
00:27:05,820 --> 00:27:07,700
No necesita nada.

508
00:27:07,700 --> 00:27:10,740
Bueno, pues, venga, este método.

509
00:27:10,740 --> 00:27:15,380
Lo mismo, a hacerlo en un ratín.