1
00:00:00,000 --> 00:00:07,680
que el teléfono se caracterizaba, su foto es la capacidad que tiene,

2
00:00:07,680 --> 00:00:10,880
o sea no la capacidad que tiene libre en cada momento,

3
00:00:10,880 --> 00:00:14,120
esa variable simplemente es la capacidad suya.

4
00:00:14,120 --> 00:00:19,120
Entonces esa variable podríamos en realidad interpretarla como un valor constante,

5
00:00:19,120 --> 00:00:24,920
en programación de toda la vida se mencionaba el concepto variables y constantes,

6
00:00:24,920 --> 00:00:28,720
pues lo de constantes es un término que se ha ido fuera,

7
00:00:28,720 --> 00:00:33,040
como lo del break es otro término que se ha ido fuera,

8
00:00:33,040 --> 00:00:36,480
como lo de las variables globales, es otro término que se ha ido fuera,

9
00:00:36,480 --> 00:00:43,680
porque son conceptos que dificultan de alguna manera las buenas prácticas de programación,

10
00:00:43,680 --> 00:00:46,920
pues el concepto de constante de toda la vida que era,

11
00:00:46,920 --> 00:00:54,200
era un valor, una variable que va a tener un valor fijo y que ese valor no va a cambiar nunca,

12
00:00:54,200 --> 00:00:58,480
y es tan importante que no cambie nunca y que nadie lo cambie por error,

13
00:00:58,480 --> 00:01:01,600
que yo lo declaro como constante,

14
00:01:01,600 --> 00:01:05,600
entonces antes se declaraban de forma diferente las variables y las constantes,

15
00:01:05,600 --> 00:01:10,600
eso ya de alguna manera se ha ido perdiendo,

16
00:01:10,600 --> 00:01:14,240
pero aún así esa idea sigue existiendo,

17
00:01:14,240 --> 00:01:17,920
la idea de que una aplicación tenga un valor para una variable

18
00:01:17,920 --> 00:01:22,720
y que me interesa a mí que ese valor no cambie nunca,

19
00:01:22,720 --> 00:01:24,920
pues entonces por ejemplo esta variable de aquí,

20
00:01:24,920 --> 00:01:29,240
esta variable capacidad, es una variable que caracteriza al móvil

21
00:01:29,240 --> 00:01:34,240
y es la capacidad máxima en gigas que tiene,

22
00:01:34,240 --> 00:01:38,840
entonces podríamos interpretarla como que es un valor constante,

23
00:01:38,840 --> 00:01:41,160
podríamos interpretarla,

24
00:01:41,160 --> 00:01:45,680
hombre a menos si se le pone una ampliación de memoria o lo que sea podría tener más,

25
00:01:45,680 --> 00:01:49,000
pero bueno vamos a imaginar que es un ejemplo de situación

26
00:01:49,000 --> 00:01:52,680
en la cual una variable tiene un valor que yo quiero que no cambie,

27
00:01:52,720 --> 00:01:56,240
eso es lo que sería el concepto de una constante,

28
00:01:56,240 --> 00:01:58,400
lo que sería el concepto de una constante,

29
00:01:58,400 --> 00:02:00,680
entonces en Java y en todos los lenguajes de programación

30
00:02:00,680 --> 00:02:04,280
pues se incorpora algo para poder representar esa idea,

31
00:02:04,280 --> 00:02:08,400
o sea el concepto de variable constante no existe en Java,

32
00:02:08,400 --> 00:02:13,920
pero sí existen modificadores para hacer que una variable se comporte así,

33
00:02:13,920 --> 00:02:15,680
como constante,

34
00:02:15,680 --> 00:02:20,600
y es uno de los pocos modificadores que nos faltan por incorporar,

35
00:02:20,600 --> 00:02:29,840
que es este modificador,

36
00:02:29,840 --> 00:02:41,760
entonces este modificador significa el valor de esta variable,

37
00:02:41,760 --> 00:02:45,480
una vez que lo reciba no se puede cambiar,

38
00:02:45,480 --> 00:02:48,080
una vez que lo reciba no se puede cambiar,

39
00:02:48,080 --> 00:02:51,280
eso significa el modificador final,

40
00:02:51,280 --> 00:02:53,960
una variable que tiene el modificador final significa

41
00:02:53,960 --> 00:02:56,160
una vez que la variable reciba este valor,

42
00:02:56,160 --> 00:03:01,000
una vez que lo reciba ya no se puede cambiar,

43
00:03:01,000 --> 00:03:03,720
entonces hace el papel de constante de toda la vida

44
00:03:03,720 --> 00:03:05,880
y a veces es útil ponerlo así,

45
00:03:05,880 --> 00:03:08,600
el modificador final se usa en más sitios,

46
00:03:08,600 --> 00:03:12,600
o sea el modificador final se puede usar aquí también en clases,

47
00:03:12,600 --> 00:03:14,520
se puede usar en métodos,

48
00:03:14,560 --> 00:03:18,080
pero cuando se usa en clases o en métodos significa otra cosa,

49
00:03:18,080 --> 00:03:20,480
y eso ya lo veremos cuando veamos herencia e implementación,

50
00:03:20,480 --> 00:03:22,920
porque está relacionada con eso,

51
00:03:22,920 --> 00:03:26,800
pero el modificador final en una variable significa,

52
00:03:26,800 --> 00:03:29,040
esta variable una vez que reciba su valor,

53
00:03:29,040 --> 00:03:31,400
ese valor ya no se puede tocar,

54
00:03:31,400 --> 00:03:35,400
entonces es una idea que puede tener su interés reflejarla,

55
00:03:35,400 --> 00:03:37,520
entonces aquí para incorporar ese modificador,

56
00:03:37,520 --> 00:03:39,720
pues ya que estamos para incorporarlo,

57
00:03:39,720 --> 00:03:43,480
vamos por ejemplo a ponerle aquí final a capacidad,

58
00:03:43,480 --> 00:03:46,000
y así aseguramos que el que haga esta aplicación,

59
00:03:46,000 --> 00:03:48,360
el que luego desarrolle para este teléfono,

60
00:03:48,360 --> 00:03:50,720
no va a poderle cambiar la capacidad según le dé la gana,

61
00:03:50,720 --> 00:03:52,800
no va a poder cambiarla,

62
00:03:52,800 --> 00:03:55,800
lo que pasa es que el poner final significa,

63
00:03:55,800 --> 00:03:58,000
que estás obligada a darle un valor,

64
00:03:58,000 --> 00:04:00,600
estás obligada a darle un valor a esa variable,

65
00:04:00,600 --> 00:04:03,960
entonces normalmente el sitio, hay matices para esto,

66
00:04:03,960 --> 00:04:06,400
pero bueno el sitio de darle el valor a la variable,

67
00:04:06,400 --> 00:04:08,480
es en el momento en el que la variable está final,

68
00:04:08,480 --> 00:04:11,160
es en el momento en el que la declaras,

69
00:04:11,160 --> 00:04:17,080
sería el momento de darle el valor,

70
00:04:17,080 --> 00:04:20,600
o dárselo aquí en el constructor en el momento en el cual,

71
00:04:20,600 --> 00:04:30,520
depende de U, depende de tu aplicación,

72
00:04:30,520 --> 00:04:35,040
claro por lo que te digo, porque te obliga a inicializarla,

73
00:04:35,040 --> 00:04:36,880
entonces al ponerle final significa,

74
00:04:36,880 --> 00:04:38,720
esta variable es constante,

75
00:04:38,760 --> 00:04:41,280
pero entonces no la dejes abierta,

76
00:04:41,280 --> 00:04:42,600
no la dejes abierta,

77
00:04:42,600 --> 00:04:44,440
entonces, bueno ya que he puesto 30,

78
00:04:44,440 --> 00:04:48,080
eso haría que todos los móviles tienen capacidad 30,

79
00:04:48,080 --> 00:04:51,120
hombre aquí lo natural sería a lo mejor,

80
00:04:51,120 --> 00:04:54,680
ponerle cuando tú instancias el móvil,

81
00:04:54,680 --> 00:04:57,640
pues decir voy a instanciar el móvil,

82
00:04:57,640 --> 00:04:59,160
con una capacidad en concreto,

83
00:04:59,160 --> 00:05:01,920
vale por ejemplo,

84
00:05:01,920 --> 00:05:16,920
y ahora aquí me falta el,

85
00:05:16,920 --> 00:05:19,280
por ejemplo,

86
00:05:19,280 --> 00:05:21,880
vale entonces aquí tendríamos un constructor,

87
00:05:21,880 --> 00:05:24,680
un constructor que te permite instanciar un teléfono,

88
00:05:24,680 --> 00:05:26,960
con una capacidad máxima,

89
00:05:26,960 --> 00:05:28,600
entonces voy a volver a ponerle sin parámetros,

90
00:05:28,600 --> 00:05:30,520
porque me lo he ventilado y siempre un constructor,

91
00:05:30,520 --> 00:05:33,560
sin parámetros,

92
00:05:33,560 --> 00:05:34,400
interesa tenerlo,

93
00:05:34,400 --> 00:05:37,840
porque puede ser que otros quieran usarlo,

94
00:05:37,840 --> 00:05:38,400
ah bueno no,

95
00:05:38,400 --> 00:05:39,440
no voy a poder,

96
00:05:39,440 --> 00:05:40,720
si pongo el constructor sin parámetros,

97
00:05:40,720 --> 00:05:42,080
me va a obligar a ponerlo aquí,

98
00:05:42,080 --> 00:05:43,000
perdón, perdón,

99
00:05:43,000 --> 00:05:43,640
he hecho una tontería,

100
00:05:43,640 --> 00:05:44,720
he hecho una tontería,

101
00:05:44,720 --> 00:05:45,840
vale,

102
00:05:45,840 --> 00:05:46,640
bueno entonces,

103
00:05:46,640 --> 00:05:49,480
la variable final significa eso,

104
00:05:49,480 --> 00:05:51,000
la variable final significa,

105
00:05:51,000 --> 00:05:51,760
claro,

106
00:05:51,760 --> 00:05:53,680
la variable final significa,

107
00:05:53,680 --> 00:05:57,040
oye esta variable cuando reciba valor,

108
00:05:57,040 --> 00:05:59,160
no puede ser cambiado,

109
00:05:59,160 --> 00:06:00,720
pero el poner final a una variable,

110
00:06:00,720 --> 00:06:01,920
luego ya tiene implicaciones,

111
00:06:01,920 --> 00:06:04,040
y es que te va a obligar a darle un valor inicial,

112
00:06:04,040 --> 00:06:04,520
etcétera,

113
00:06:04,520 --> 00:06:06,080
entonces tú eliges cómo dárselo,

114
00:06:06,080 --> 00:06:06,720
en qué momento,

115
00:06:06,720 --> 00:06:08,320
si a través del constructor,

116
00:06:08,320 --> 00:06:10,160
bueno ya depende de tu aplicación,

117
00:06:10,160 --> 00:06:10,440
vale,

118
00:06:10,440 --> 00:06:13,360
entonces cuidado simplemente con que una variable sea final,

119
00:06:13,360 --> 00:06:15,800
te obliga a darle un valor,

120
00:06:15,800 --> 00:06:18,400
y ese valor ya no se va a quitar,

121
00:06:18,400 --> 00:06:19,240
vale,

122
00:06:19,240 --> 00:06:20,320
entonces aquí por ejemplo,

123
00:06:20,320 --> 00:06:23,440
pues podemos optar por esto,

124
00:06:23,440 --> 00:06:25,160
entonces los get y los set,

125
00:06:25,160 --> 00:06:27,440
qué ocurre con las variables final,

126
00:06:27,440 --> 00:06:28,840
pues que los get y los set,

127
00:06:28,840 --> 00:06:30,720
dejan de tener sentido,

128
00:06:30,720 --> 00:06:32,360
de hecho el set,

129
00:06:32,360 --> 00:06:34,080
vale,

130
00:06:34,080 --> 00:06:36,040
directamente se me ha puesto en rojo,

131
00:06:36,040 --> 00:06:36,520
me dice,

132
00:06:36,520 --> 00:06:40,120
oye cuidado que capacidad le acabas de hacer final,

133
00:06:40,120 --> 00:06:42,240
eso de asignarle un valor,

134
00:06:42,240 --> 00:06:43,400
no,

135
00:06:43,400 --> 00:06:45,520
entonces los get y los set en las variables final,

136
00:06:45,520 --> 00:06:46,640
dejan de tener sentido,

137
00:06:46,640 --> 00:06:47,840
el set está claro,

138
00:06:47,840 --> 00:06:50,120
porque hemos dicho que no podemos tocarla,

139
00:06:50,120 --> 00:06:53,960
luego el set de la variable capacidad,

140
00:06:53,960 --> 00:06:55,040
fuera,

141
00:06:55,040 --> 00:06:57,080
lo voy a poner con un comentario,

142
00:06:57,080 --> 00:06:59,400
para que quede claro,

143
00:06:59,400 --> 00:07:03,000
porque lo hemos quitado,

144
00:07:03,000 --> 00:07:08,520
capacidad es variable final,

145
00:07:08,520 --> 00:07:17,440
con lo cual el set pierde el sentido,

146
00:07:17,440 --> 00:07:17,680
vale,

147
00:07:17,680 --> 00:07:18,680
o sea tienen un uso,

148
00:07:18,680 --> 00:07:19,880
digamos que las variables final,

149
00:07:19,880 --> 00:07:21,200
tienen un uso como muy concreto,

150
00:07:21,200 --> 00:07:24,480
y Java se adapta a que las usemos así,

151
00:07:24,480 --> 00:07:24,800
vale,

152
00:07:24,800 --> 00:07:31,320
entonces lo voy a comentar,

153
00:07:31,320 --> 00:07:32,520
vale,

154
00:07:32,520 --> 00:07:35,080
desde el momento en que hemos decidido ponerla final,

155
00:07:35,080 --> 00:07:37,200
este set tiene el sentido,

156
00:07:37,200 --> 00:07:38,960
el get pierde el sentido,

157
00:07:38,960 --> 00:07:40,520
hombre a ver no lo pierde,

158
00:07:40,520 --> 00:07:43,560
el get está para que yo dado un móvil,

159
00:07:43,560 --> 00:07:45,560
pueda ver la capacidad que tiene,

160
00:07:45,560 --> 00:07:45,840
vale,

161
00:07:45,840 --> 00:07:46,640
no hay ningún problema,

162
00:07:46,640 --> 00:07:48,720
yo lo podría dejar así,

163
00:07:48,720 --> 00:07:49,720
pero,

164
00:07:49,720 --> 00:07:53,600
pero el uso habitual de las variables final,

165
00:07:53,600 --> 00:07:54,880
suele ser otro,

166
00:07:54,880 --> 00:07:55,280
vale,

167
00:07:55,280 --> 00:07:56,720
suele ser otro,

168
00:07:56,720 --> 00:08:00,480
lo normal es que las se pongan public,

169
00:08:00,480 --> 00:08:02,280
y se acceda directamente,

170
00:08:02,280 --> 00:08:03,600
a través del nombre de la clase,

171
00:08:03,600 --> 00:08:05,480
suele ser la forma habitual de usarlas,

172
00:08:05,480 --> 00:08:06,440
vale,

173
00:08:06,440 --> 00:08:08,840
pero vamos a dejarlo ahora como está,

174
00:08:08,840 --> 00:08:10,880
vamos a dejarlo ahora como está,

175
00:08:10,880 --> 00:08:14,080
para no seguir tocando el resto de la aplicación,

176
00:08:14,080 --> 00:08:15,760
lo único que quería incorporar,

177
00:08:15,760 --> 00:08:16,720
de cara a esta aplicación,

178
00:08:16,720 --> 00:08:18,760
lo único que quería incorporar era,

179
00:08:18,760 --> 00:08:21,680
el concepto de modificador final en variables,

180
00:08:21,680 --> 00:08:27,640
porque en métodos y clases significa otra cosa,

181
00:08:27,640 --> 00:08:29,240
pues en variables significa,

182
00:08:29,240 --> 00:08:30,160
esa variable,

183
00:08:30,160 --> 00:08:31,320
una vez que reciba el valor,

184
00:08:31,320 --> 00:08:32,400
no se puede tocar,

185
00:08:32,400 --> 00:08:33,960
es una constante,

186
00:08:33,960 --> 00:08:36,160
vale,

187
00:08:36,160 --> 00:08:37,440
entonces,

188
00:08:37,440 --> 00:08:38,520
si lo ponemos final,

189
00:08:38,520 --> 00:08:41,120
va a tener luego implicaciones en nuestra aplicación,

190
00:08:41,120 --> 00:08:43,080
y es que nos va a obligar a darle ese valor,

191
00:08:43,080 --> 00:08:44,440
no se puede quedar indefinido,

192
00:08:44,440 --> 00:08:45,040
etcétera,

193
00:08:45,040 --> 00:08:45,960
simplemente eso,

194
00:08:45,960 --> 00:08:46,280
vale,

195
00:08:46,280 --> 00:08:48,240
simplemente eso,

196
00:08:48,240 --> 00:08:49,400
bueno,

197
00:08:49,400 --> 00:08:49,920
pues ya está,

198
00:08:49,920 --> 00:08:51,240
vamos a poner,

199
00:08:51,240 --> 00:08:53,400
capacidad a valor constante,

200
00:08:53,400 --> 00:08:55,120
para que una vez que hemos creado el móvil,

201
00:08:55,120 --> 00:08:58,560
con un tamaño de gigas,

202
00:08:58,560 --> 00:09:01,640
nos aseguremos de que el resto de la aplicación no lo va a tocar,

203
00:09:01,640 --> 00:09:01,840
vale,

204
00:09:01,840 --> 00:09:04,240
a lo mejor puede ser que nos interesa que eso sea así,

205
00:09:04,240 --> 00:09:04,520
bueno,

206
00:09:04,520 --> 00:09:05,720
pues venga,

207
00:09:05,720 --> 00:09:08,640
vamos a hacer como que nos interesa que eso sea así,

208
00:09:08,640 --> 00:09:12,160
y así aprovechamos para incorporar ese modificador,

209
00:09:12,160 --> 00:09:13,400
vale,

210
00:09:13,400 --> 00:09:13,680
bueno,

211
00:09:13,680 --> 00:09:14,280
pues ya está,

212
00:09:14,280 --> 00:09:14,600
entonces,

213
00:09:14,600 --> 00:09:16,560
nuestra clase móvil tenía,

214
00:09:16,560 --> 00:09:17,840
su foto era,

215
00:09:17,840 --> 00:09:18,960
la capacidad,

216
00:09:18,960 --> 00:09:22,120
una vez que ha recibido la capacidad en el momento de ser creado,

217
00:09:22,120 --> 00:09:24,000
esa no se toca,

218
00:09:24,000 --> 00:09:25,320
el almacén de aplicaciones,

219
00:09:25,320 --> 00:09:25,880
bueno hombre,

220
00:09:25,880 --> 00:09:27,920
pues no le ponen,

221
00:09:27,920 --> 00:09:28,960
puede ser variable,

222
00:09:28,960 --> 00:09:30,960
y las instaladas,

223
00:09:30,960 --> 00:09:32,200
ya está,

224
00:09:32,200 --> 00:09:32,960
vale,

225
00:09:32,960 --> 00:09:34,640
el modificador final,

226
00:09:34,640 --> 00:09:35,840
hay que tener cuidado con él,

227
00:09:35,840 --> 00:09:37,040
se usa,

228
00:09:37,040 --> 00:09:37,880
solo,

229
00:09:37,880 --> 00:09:40,040
si realmente aporta a la aplicación,

230
00:09:40,040 --> 00:09:40,880
si le aporta,

231
00:09:40,880 --> 00:09:42,440
porque es muy peligroso también,

232
00:09:42,440 --> 00:09:45,560
es muy peligroso porque resta mucha libertad,

233
00:09:45,560 --> 00:09:46,600
entonces de nuevo,

234
00:09:46,600 --> 00:09:47,840
es lo de siempre,

235
00:09:47,840 --> 00:09:49,680
cuidado con los diseños,

236
00:09:49,680 --> 00:09:52,200
los diseños es que clases voy a usar,

237
00:09:52,200 --> 00:09:54,560
qué variables me interesan cada clase,

238
00:09:54,560 --> 00:09:55,960
qué tipo,

239
00:09:55,960 --> 00:09:57,600
todo eso que son cuestiones de diseño,

240
00:09:57,600 --> 00:09:59,640
cuidado con ellos porque son,

241
00:09:59,640 --> 00:10:01,120
realmente lo más importante,

242
00:10:01,120 --> 00:10:04,160
más que luego a la hora de hacer el método y hacer el código,

243
00:10:04,160 --> 00:10:05,720
porque eso ya es hacer bucles,

244
00:10:05,720 --> 00:10:06,080
for,

245
00:10:06,080 --> 00:10:07,200
if,

246
00:10:07,200 --> 00:10:08,720
cuidado con la parte de diseño,

247
00:10:08,720 --> 00:10:12,000
hay muchas formas de hacer diseños distintos,

248
00:10:12,000 --> 00:10:15,320
y algunas pues hacen aplicaciones más dificultosas que otras,

249
00:10:15,320 --> 00:10:15,520
vale,

250
00:10:15,520 --> 00:10:16,760
entonces cuidado,

251
00:10:16,760 --> 00:10:19,680
con decidir alegremente que una variable sea final o no,

252
00:10:19,680 --> 00:10:21,400
si aporta a la aplicación,

253
00:10:21,400 --> 00:10:22,280
sí,

254
00:10:22,280 --> 00:10:23,720
pero si no,

255
00:10:23,720 --> 00:10:25,840
si no es imprescindible,

256
00:10:25,840 --> 00:10:27,200
si no aporta,

257
00:10:27,200 --> 00:10:28,480
no.

258
00:10:28,480 --> 00:10:31,520
¿Y si resulta un fallo en el método?

259
00:10:31,520 --> 00:10:31,920
Eh,

260
00:10:31,920 --> 00:10:32,680
si habrán fallado,

261
00:10:32,680 --> 00:10:34,400
con este cambio puede que hayan fallado más cosas,

262
00:10:34,400 --> 00:10:34,920
si no lo sé,

263
00:10:34,920 --> 00:10:37,320
tenemos que revisarlo,

264
00:10:37,320 --> 00:10:38,320
vamos a ver,

265
00:10:38,320 --> 00:10:39,120
eh,

266
00:10:39,120 --> 00:10:40,080
vamos a revisar la clase,

267
00:10:40,080 --> 00:10:41,760
por ahora teníamos,

268
00:10:41,760 --> 00:10:43,920
las tres variables que caracterizan al teléfono,

269
00:10:43,920 --> 00:10:46,080
y hemos puesto que una sea final,

270
00:10:46,120 --> 00:10:47,080
vale,

271
00:10:47,080 --> 00:10:48,040
los constructores,

272
00:10:48,040 --> 00:10:49,760
uno que fija solamente la capacidad,

273
00:10:49,760 --> 00:10:50,960
y luego a través de set,

274
00:10:50,960 --> 00:10:52,080
los otras,

275
00:10:52,080 --> 00:10:55,000
si ya no tendríamos constructor vacío,

276
00:10:55,000 --> 00:10:56,440
eh,

277
00:10:56,440 --> 00:10:57,960
es que,

278
00:10:57,960 --> 00:11:00,640
si ponemos un constructor vacío,

279
00:11:00,640 --> 00:11:01,400
claro,

280
00:11:01,400 --> 00:11:02,400
te dice,

281
00:11:02,400 --> 00:11:05,080
tendríamos que inicializar la capacidad aquí,

282
00:11:05,080 --> 00:11:05,680
claro,

283
00:11:05,680 --> 00:11:07,120
entonces ya inicializamos aquí,

284
00:11:07,120 --> 00:11:08,560
el problema que tenemos es que,

285
00:11:08,560 --> 00:11:09,960
cualquier teléfono,

286
00:11:09,960 --> 00:11:11,240
que se instancie,

287
00:11:11,240 --> 00:11:13,880
cualquier teléfono que se instancie va a tener la misma capacidad,

288
00:11:13,880 --> 00:11:15,960
y no queremos eso,

289
00:11:15,960 --> 00:11:18,320
entonces claro hay que adaptarse a la aplicación,

290
00:11:18,320 --> 00:11:20,520
en este caso no podemos poner un constructor sin parámetros,

291
00:11:20,520 --> 00:11:22,040
a menos que,

292
00:11:22,040 --> 00:11:23,280
la inicialicemos ahí,

293
00:11:23,280 --> 00:11:25,560
y no queremos hacer eso porque no se adapta,

294
00:11:25,560 --> 00:11:26,680
vale,

295
00:11:26,680 --> 00:11:28,040
normalmente es que,

296
00:11:28,040 --> 00:11:30,720
el uso de las variables final suele ser,

297
00:11:30,720 --> 00:11:32,040
cuando son constantes,

298
00:11:32,040 --> 00:11:33,360
que son iguales,

299
00:11:33,360 --> 00:11:35,720
para todos los objetos de una clase,

300
00:11:35,720 --> 00:11:37,000
que son iguales para todos,

301
00:11:37,000 --> 00:11:38,760
con lo cual además sería en static,

302
00:11:38,760 --> 00:11:40,680
por eso a veces,

303
00:11:40,680 --> 00:11:43,280
cuando veis final lo soléis ver asociado a static,

304
00:11:43,280 --> 00:11:44,480
muchas veces,

305
00:11:44,480 --> 00:11:45,880
porque es donde tiene más sentido,

306
00:11:45,880 --> 00:11:47,000
donde tiene más sentido,

307
00:11:47,000 --> 00:11:49,800
o sea mi aplicación tiene una constante,

308
00:11:49,800 --> 00:11:51,680
que es un valor que yo quiero que sea ese,

309
00:11:51,680 --> 00:11:54,080
el mismo para todos los objetos de la clase,

310
00:11:54,080 --> 00:11:55,600
y además no cambiarlo,

311
00:11:55,600 --> 00:11:57,680
pues la combinación de esas dos ideas es,

312
00:11:57,680 --> 00:11:58,280
static,

313
00:11:58,280 --> 00:11:59,560
porque es el mismo para todos,

314
00:11:59,560 --> 00:11:59,960
y final,

315
00:11:59,960 --> 00:12:01,400
la combinación de esas dos ideas,

316
00:12:01,400 --> 00:12:01,640
vale,

317
00:12:01,640 --> 00:12:03,160
que suele ser el uso habitual,

318
00:12:03,160 --> 00:12:05,800
suele ser el uso habitual porque responde a muchas situaciones,

319
00:12:05,800 --> 00:12:07,480
que uno quiere reflejar,

320
00:12:07,480 --> 00:12:10,160
aquí es que es otra situación,

321
00:12:10,160 --> 00:12:12,560
cada móvil tiene su propia capacidad,

322
00:12:12,560 --> 00:12:13,720
pero distinta,

323
00:12:13,720 --> 00:12:15,320
con lo cual esa variable no puede ser static,

324
00:12:16,240 --> 00:12:18,680
porque cada móvil tiene la suya propia,

325
00:12:18,680 --> 00:12:19,680
pero luego cada móvil,

326
00:12:19,680 --> 00:12:20,600
la suya propia,

327
00:12:20,600 --> 00:12:23,360
una vez creada no la puedo cambiar,

328
00:12:23,360 --> 00:12:25,160
esta es otra situación distinta,

329
00:12:25,160 --> 00:12:27,120
y en esta situación entonces,

330
00:12:27,120 --> 00:12:32,040
yo si pongo un constructor sin parámetros,

331
00:12:32,040 --> 00:12:32,280
vale,

332
00:12:32,280 --> 00:12:32,960
pues entonces a ver,

333
00:12:32,960 --> 00:12:35,120
podría poner un constructor sin parámetros,

334
00:12:35,120 --> 00:12:37,400
y en el constructor inicializar capacidad,

335
00:12:37,400 --> 00:12:38,760
pidiéndolo por teclado,

336
00:12:38,760 --> 00:12:40,360
qué capacidad quiere para el teléfono,

337
00:12:40,360 --> 00:12:41,120
por ejemplo,

338
00:12:41,120 --> 00:12:44,640
pero me va a obligar a inicializar capacidad,

339
00:12:44,800 --> 00:12:45,880
me va a obligar a inicializarlo,

340
00:12:45,880 --> 00:12:47,200
ese es el problema,

341
00:12:47,200 --> 00:12:49,440
que dejar uno sin parámetros y vacío,

342
00:12:49,440 --> 00:12:50,040
no puedo,

343
00:12:50,040 --> 00:12:53,320
la variable capacidad tiene que recibir un valor cuando el objeto se instancia,

344
00:12:53,320 --> 00:12:54,760
ese es el asunto,

345
00:12:54,760 --> 00:12:56,960
y yo ya programo y me adapto a eso,

346
00:12:56,960 --> 00:12:57,600
en este caso,

347
00:12:57,600 --> 00:12:58,560
pues bueno,

348
00:12:58,560 --> 00:13:00,720
hago este constructor,

349
00:13:00,720 --> 00:13:03,520
en el que la inicializo al valor que sea,

350
00:13:03,520 --> 00:13:05,120
y ya está,

351
00:13:05,120 --> 00:13:08,040
y dejo este otro,

352
00:13:08,040 --> 00:13:08,280
vale,

353
00:13:08,280 --> 00:13:11,920
pues seguimos repasando esta clase,

354
00:13:11,920 --> 00:13:14,920
la foto de las tres cosas,

355
00:13:14,920 --> 00:13:17,240
el get capacidad lo vamos a dejar ahí,

356
00:13:17,240 --> 00:13:22,400
para recoger la capacidad cuando la queramos,

357
00:13:22,400 --> 00:13:23,400
hemos modificado el set,

358
00:13:23,400 --> 00:13:26,080
porque el set aquí ya deja de tener sentido,

359
00:13:26,080 --> 00:13:30,200
el get y set de esto de aquí,

360
00:13:30,200 --> 00:13:32,480
el get y set de las instaladas,

361
00:13:32,480 --> 00:13:35,440
navegar por el app store,

362
00:13:35,440 --> 00:13:37,040
y el status,

363
00:13:37,040 --> 00:13:37,560
vale,

364
00:13:37,560 --> 00:13:39,680
el status que te muestra los datos,

365
00:13:39,680 --> 00:13:40,800
porque decías tú que el status,

366
00:13:40,800 --> 00:13:41,040
o sea,

367
00:13:41,040 --> 00:13:42,480
si el status es para mostrar solo,

368
00:13:42,480 --> 00:13:49,120
entonces no,

369
00:13:49,120 --> 00:13:49,560
claro,

370
00:13:49,560 --> 00:13:50,840
pero porque tú lo que hacías,

371
00:13:50,840 --> 00:13:51,840
te acuerdas que lo dijimos ayer,

372
00:13:51,840 --> 00:13:54,040
tú hacías capacidad menos igual,

373
00:13:54,040 --> 00:13:54,840
y te dije no,

374
00:13:54,840 --> 00:13:55,800
no uses esa variable,

375
00:13:55,800 --> 00:13:57,280
usa otra auxiliar,

376
00:13:57,280 --> 00:13:58,840
porque la variable capacidad,

377
00:13:58,840 --> 00:14:00,160
que es la que dice la capacidad del móvil,

378
00:14:00,160 --> 00:14:01,080
no queremos tocarla,

379
00:14:01,080 --> 00:14:05,160
queremos que el móvil tenga siempre la misma capacidad,

380
00:14:05,160 --> 00:14:05,600
entonces claro,

381
00:14:05,600 --> 00:14:09,680
a ti se te ha puesto en rojo cuando has intentado modificar esa variable,

382
00:14:09,680 --> 00:14:10,040
pero claro,

383
00:14:10,040 --> 00:14:15,400
yo no he intentado modificarla,

384
00:14:15,400 --> 00:14:15,720
vale,

385
00:14:15,720 --> 00:14:18,120
y ahora estábamos con este,

386
00:14:18,120 --> 00:14:19,360
vale,

387
00:14:19,360 --> 00:14:20,400
recibe un nombre,

388
00:14:20,400 --> 00:14:24,880
la busca en el app store este,

389
00:14:24,880 --> 00:14:25,120
bueno,

390
00:14:25,120 --> 00:14:27,640
primero tendrá que mirar a ver si está instalada,

391
00:14:27,640 --> 00:14:28,520
y si está instalada,

392
00:14:28,520 --> 00:14:31,040
porque y si está instalada,

393
00:14:31,040 --> 00:14:34,680
pues mira a ver si la del app store es una versión mayor para recuperar esa,

394
00:14:34,680 --> 00:14:36,040
y si no está instalada,

395
00:14:36,040 --> 00:14:38,520
la instala,

396
00:14:38,520 --> 00:14:41,400
lo habéis hecho más o menos,

397
00:14:41,400 --> 00:14:42,440
tú lo has hecho,

398
00:14:42,440 --> 00:14:43,480
te ha quedado esa cosa larga,

399
00:14:43,480 --> 00:14:45,240
pero bien,

400
00:14:45,240 --> 00:14:46,240
o ya la has encogido,

401
00:14:46,240 --> 00:14:46,520
a ver,

402
00:14:46,520 --> 00:14:48,200
es que,

403
00:14:48,200 --> 00:14:48,440
claro,

404
00:14:48,440 --> 00:14:48,640
a ver,

405
00:14:48,640 --> 00:14:50,440
si uno se pone a hacer esto así,

406
00:14:50,440 --> 00:14:50,560
pa,

407
00:14:50,560 --> 00:14:50,720
pa,

408
00:14:50,720 --> 00:14:51,640
pa,

409
00:14:51,640 --> 00:14:52,920
de seguido,

410
00:14:52,920 --> 00:14:54,360
que es como estamos haciendo aquí las cosas,

411
00:14:54,360 --> 00:14:54,560
o sea,

412
00:14:54,560 --> 00:14:56,640
yo aquí estoy haciendo las cosas,

413
00:14:56,640 --> 00:14:58,320
lo pongo esto en blanco directamente,

414
00:14:58,320 --> 00:15:02,760
y me pongo a pensar en paralelo con vosotros sobre la marcha,

415
00:15:02,760 --> 00:15:05,360
porque es el proceso que vosotros seguís,

416
00:15:05,360 --> 00:15:05,720
y claro,

417
00:15:05,720 --> 00:15:06,600
es normal,

418
00:15:06,600 --> 00:15:08,360
de eso salen cosas raras,

419
00:15:08,360 --> 00:15:09,520
pero luego sobre eso,

420
00:15:09,520 --> 00:15:10,360
uno va iterando,

421
00:15:10,360 --> 00:15:11,960
va viendo a ver si puede cambiar algo,

422
00:15:11,960 --> 00:15:13,280
es el proceso de aprender,

423
00:15:13,280 --> 00:15:13,840
y luego ya,

424
00:15:13,840 --> 00:15:15,160
pues cuando pasa mucho tiempo,

425
00:15:15,160 --> 00:15:17,240
pues a lo mejor a uno ya de partida,

426
00:15:17,240 --> 00:15:21,000
le salen códigos más compactos de buenas a primeras,

427
00:15:21,000 --> 00:15:22,560
pero si uno se pone a hacer esto de cero,

428
00:15:22,560 --> 00:15:24,400
así lo normal es que le acabes,

429
00:15:24,400 --> 00:15:26,640
al principio le sale una cosa muy rara,

430
00:15:26,640 --> 00:15:28,760
¿vale?

431
00:15:28,760 --> 00:15:30,400
Vale,

432
00:15:30,400 --> 00:15:31,760
¿alguien más lo ha hecho aparte de él?

433
00:15:31,760 --> 00:15:33,280
No es por regañar ni por poner nota,

434
00:15:33,280 --> 00:15:38,720
es por,

435
00:15:38,720 --> 00:15:39,400
vale, pues venga,

436
00:15:39,400 --> 00:15:42,520
vamos a plantearnos entonces hacerlo,

437
00:15:42,520 --> 00:15:43,200
a ver,

438
00:15:43,200 --> 00:15:44,920
¿qué nos sale?

439
00:15:44,920 --> 00:15:45,200
Venga,

440
00:15:45,200 --> 00:15:47,400
apunto de lo que tenemos claro es que nos dan el nombre de una

441
00:15:47,400 --> 00:15:49,200
aplicación,

442
00:15:49,200 --> 00:15:51,000
entonces,

443
00:15:51,000 --> 00:15:53,080
hay que tomar varias decisiones,

444
00:15:53,080 --> 00:15:53,520
una,

445
00:15:53,520 --> 00:15:55,600
¿está instalado o no lo está?

446
00:15:55,600 --> 00:15:57,040
Si no lo está,

447
00:15:57,040 --> 00:15:58,720
si no está instalada,

448
00:15:58,720 --> 00:16:00,320
se trata de instalarla,

449
00:16:00,320 --> 00:16:00,760
vale,

450
00:16:00,760 --> 00:16:01,760
hasta ahí sencillo,

451
00:16:01,760 --> 00:16:02,920
si no lo está es instalarla,

452
00:16:02,920 --> 00:16:03,400
¿verdad?

453
00:16:03,400 --> 00:16:04,880
A ver si entiendo bien el enunciado,

454
00:16:04,880 --> 00:16:06,120
si no me lo decís,

455
00:16:06,120 --> 00:16:07,560
y si está,

456
00:16:07,560 --> 00:16:08,240
ahí se me pueden,

457
00:16:08,240 --> 00:16:10,240
se me abren otras dos ramas,

458
00:16:10,240 --> 00:16:12,120
la versión que está,

459
00:16:12,120 --> 00:16:12,880
es igual,

460
00:16:12,880 --> 00:16:16,040
tiene la misma versión que la de la péstora o menor,

461
00:16:16,040 --> 00:16:18,760
porque si la tiene igual no hago nada,

462
00:16:18,760 --> 00:16:21,040
y si la tiene menor,

463
00:16:21,040 --> 00:16:22,280
la actualizo,

464
00:16:22,280 --> 00:16:22,560
¿vale?

465
00:16:22,560 --> 00:16:23,200
Entonces,

466
00:16:23,200 --> 00:16:24,720
son una primera rama,

467
00:16:24,720 --> 00:16:25,960
está o no está,

468
00:16:25,960 --> 00:16:27,720
y en la rama de,

469
00:16:27,720 --> 00:16:28,520
está,

470
00:16:28,520 --> 00:16:30,160
a su vez tendré que hacerle otra pregunta,

471
00:16:30,160 --> 00:16:31,440
podemos planteárnoslo así,

472
00:16:31,440 --> 00:16:34,720
uno tiene que ver de alguna manera en la cabeza el flujo,

473
00:16:34,720 --> 00:16:36,680
¿cuál va a ser el flujo de su código?

474
00:16:36,680 --> 00:16:38,680
Pues el flujo ahora mismo sería,

475
00:16:38,680 --> 00:16:41,400
vamos a hacernos la primera pregunta,

476
00:16:41,400 --> 00:16:44,920
en función de lo que me dé alguna cosa o la otra,

477
00:16:44,920 --> 00:16:46,560
y luego ya en cada rama,

478
00:16:46,560 --> 00:16:49,480
si me tengo que hacer otra pregunta me la sigo haciendo.

479
00:16:49,480 --> 00:16:49,720
Bueno,

480
00:16:49,720 --> 00:16:51,720
pues entonces vamos a ver primero si está instalada,

481
00:16:51,720 --> 00:16:54,160
ver si está instalada o no,

482
00:16:54,160 --> 00:16:57,200
se tratará de recorrer las instaladas,

483
00:16:57,200 --> 00:16:59,720
a ver si alguna de ellas,

484
00:16:59,720 --> 00:17:06,160
su nombre es igual a este de aquí,

485
00:17:06,160 --> 00:17:07,280
¿vale?

486
00:17:07,280 --> 00:17:09,560
Pues venga,

487
00:17:09,560 --> 00:17:12,520
vamos a hacerlo.

488
00:17:12,520 --> 00:17:14,240
Primero,

489
00:17:14,240 --> 00:17:19,120
comprobamos si ya está instalada,

490
00:17:19,120 --> 00:17:19,360
¿vale?

491
00:17:19,360 --> 00:17:20,760
Vamos haciéndonos las ramas,

492
00:17:20,760 --> 00:17:21,240
el flujo,

493
00:17:21,240 --> 00:17:23,880
le vamos haciendo las ramitas,

494
00:17:23,880 --> 00:17:24,600
pues nada,

495
00:17:24,600 --> 00:17:25,960
comprobar si ya está instalada,

496
00:17:25,960 --> 00:17:27,360
pues por ejemplo,

497
00:17:27,360 --> 00:17:29,720
podemos decir,

498
00:17:29,720 --> 00:17:30,760
boolean instalada,

499
00:17:30,760 --> 00:17:32,760
yo asumo que no,

500
00:17:32,760 --> 00:17:34,720
y ahora voy a ver si lo está,

501
00:17:34,720 --> 00:17:35,000
¿vale?

502
00:17:35,000 --> 00:17:36,440
Porque esto de nuevo es,

503
00:17:36,440 --> 00:17:38,080
voy a ver si algo pasa o no pasa,

504
00:17:38,080 --> 00:17:39,920
voy a ver si está instalado o no lo está,

505
00:17:39,920 --> 00:17:42,040
porque en función de si está o no está,

506
00:17:42,040 --> 00:17:44,120
hago una cosa o hago otra,

507
00:17:44,120 --> 00:17:46,040
vamos a intentar hacer un código,

508
00:17:46,040 --> 00:17:47,000
un flujo,

509
00:17:47,000 --> 00:17:52,240
un código organizado que responda a los patrones de pensamiento que hemos dicho,

510
00:17:52,240 --> 00:17:53,320
y nos puede quedar algo largo,

511
00:17:53,320 --> 00:17:53,760
pero bueno,

512
00:17:53,760 --> 00:17:54,360
no pasa nada,

513
00:17:54,360 --> 00:17:55,400
ya habrá tiempo,

514
00:17:55,400 --> 00:17:56,120
si,

515
00:17:56,120 --> 00:17:56,440
ah,

516
00:17:56,440 --> 00:17:56,680
vale,

517
00:17:56,680 --> 00:17:58,520
es que esto a lo mejor lo puedo reducir así,

518
00:17:58,520 --> 00:18:00,360
pues ya lo reduciremos,

519
00:18:00,360 --> 00:18:04,200
pero ahora mismo lo importante es que tengamos un pensamiento organizado,

520
00:18:04,200 --> 00:18:05,000
y estructurado,

521
00:18:05,000 --> 00:18:09,160
y que sepamos plasmarlo con los patrones que ya hemos visto,

522
00:18:09,160 --> 00:18:10,120
¿no?

523
00:18:10,120 --> 00:18:10,640
Entonces,

524
00:18:10,640 --> 00:18:12,200
¿está instalada o no está instalada?

525
00:18:12,200 --> 00:18:12,840
Vamos a verlo,

526
00:18:12,840 --> 00:18:14,320
para ver si está instalada o no,

527
00:18:14,320 --> 00:18:15,640
tengo que recorrer un array,

528
00:18:15,640 --> 00:18:16,840
pues hacemos lo de siempre,

529
00:18:16,840 --> 00:18:18,640
asumo que no está instalada,

530
00:18:18,640 --> 00:18:20,280
y ahora me pongo a recorrer esto,

531
00:18:20,280 --> 00:18:24,400
me pongo a recorrer mi array de instaladas,

532
00:18:24,400 --> 00:18:31,680
que se llamaba instaladas,

533
00:18:31,680 --> 00:18:33,680
que instaladas.len,

534
00:18:33,680 --> 00:18:36,560
incrementando i,

535
00:18:36,560 --> 00:18:37,440
vale,

536
00:18:37,440 --> 00:18:39,560
pues vamos una por una,

537
00:18:39,560 --> 00:18:45,040
si instaladas de i,

538
00:18:45,040 --> 00:18:48,040
punto get nombre,

539
00:18:48,040 --> 00:18:51,760
resulta que es igual,

540
00:18:51,760 --> 00:18:52,960
que es igual,

541
00:18:52,960 --> 00:18:57,680
que el nombre de la que me han dado que tengo que instalar,

542
00:18:57,680 --> 00:18:58,760
pues ala,

543
00:18:58,760 --> 00:19:03,800
instalada igual true,

544
00:19:03,800 --> 00:19:06,120
no sé si está muy bien elegido los nombres de las variables,

545
00:19:06,120 --> 00:19:07,920
pero se llama todo igual,

546
00:19:07,920 --> 00:19:09,680
¿vale?

547
00:19:09,680 --> 00:19:10,400
Entonces,

548
00:19:10,400 --> 00:19:14,480
ya con esto puedo saber si está o no está,

549
00:19:14,480 --> 00:19:15,880
¿vale?

550
00:19:15,880 --> 00:19:16,480
Ahora de nuevo,

551
00:19:16,480 --> 00:19:18,960
podría a lo mejor sacarme esto a un método auxiliar,

552
00:19:18,960 --> 00:19:20,480
que me diga,

553
00:19:20,480 --> 00:19:21,360
está instalada,

554
00:19:21,360 --> 00:19:22,440
y llamar aquí al método,

555
00:19:22,440 --> 00:19:23,400
si está instalada,

556
00:19:23,400 --> 00:19:23,840
pues sí,

557
00:19:23,840 --> 00:19:24,760
podríamos hacer eso,

558
00:19:24,760 --> 00:19:26,240
sacarlo a un método auxiliar,

559
00:19:26,240 --> 00:19:26,520
¿vale?

560
00:19:26,520 --> 00:19:28,120
Pero,

561
00:19:28,120 --> 00:19:28,400
vale,

562
00:19:28,400 --> 00:19:30,120
entonces ahora ya le puedo hacer la pregunta,

563
00:19:30,120 --> 00:19:32,480
ahora ya tengo una pregunta que hacerme,

564
00:19:32,480 --> 00:19:38,600
ahora ya sí que puedo,

565
00:19:38,600 --> 00:19:39,280
y es esta,

566
00:19:39,280 --> 00:19:43,640
¿verdad?

567
00:19:43,640 --> 00:19:48,800
Si está instalada o si no está instalada,

568
00:19:48,800 --> 00:19:50,080
me la voy a hacer al revés,

569
00:19:50,120 --> 00:19:52,360
para aprovecharme del retorno,

570
00:19:52,360 --> 00:19:54,800
¿vale?

571
00:19:54,800 --> 00:19:55,600
Entonces yo puedo hacer,

572
00:19:55,600 --> 00:19:56,640
que no lo está,

573
00:19:56,640 --> 00:19:58,400
que no lo está,

574
00:19:58,400 --> 00:20:00,920
pues aquí que tengo que hacerla,

575
00:20:00,920 --> 00:20:02,320
pasamos,

576
00:20:02,320 --> 00:20:03,000
instalarla,

577
00:20:03,000 --> 00:20:05,360
instalarla que será,

578
00:20:05,360 --> 00:20:08,560
instalamos la aplicación,

579
00:20:08,560 --> 00:20:10,800
instalar la aplicación que es,

580
00:20:10,800 --> 00:20:13,080
pasar una copia,

581
00:20:13,080 --> 00:20:15,680
una copia,

582
00:20:15,680 --> 00:20:21,240
de la del App Store,

583
00:20:21,240 --> 00:20:21,640
al,

584
00:20:21,640 --> 00:20:25,560
a raíz de instaladas,

585
00:20:25,560 --> 00:20:26,520
eso es instalarla,

586
00:20:26,520 --> 00:20:27,960
¿no?

587
00:20:27,960 --> 00:20:29,640
Eso es instalarla,

588
00:20:29,640 --> 00:20:31,480
y una vez que lo hayamos hecho,

589
00:20:31,480 --> 00:20:32,880
ya no tiene nada más que hacer el método,

590
00:20:32,880 --> 00:20:34,760
¿verdad?

591
00:20:34,760 --> 00:20:36,080
Si algo digo mal,

592
00:20:36,080 --> 00:20:37,520
me lo decís,

593
00:20:37,520 --> 00:20:41,640
yo estoy pensando sobre la marcha,

594
00:20:41,640 --> 00:20:42,240
¿vale?

595
00:20:42,240 --> 00:20:44,400
Entonces que no lo está,

596
00:20:44,400 --> 00:20:46,040
la instalo y fuera,

597
00:20:46,040 --> 00:20:48,240
y retorno.

598
00:20:48,240 --> 00:20:51,080
Entonces como estoy en un método,

599
00:20:51,080 --> 00:20:53,440
pues pongo el retorno y así me ahorro el ELSE,

600
00:20:53,440 --> 00:20:54,800
¿verdad?

601
00:20:54,800 --> 00:20:56,480
Si yo no pongo el retorno,

602
00:20:56,480 --> 00:20:58,080
entonces tengo que poner aquí el ELSE,

603
00:20:58,080 --> 00:21:00,800
y ya en la rama del ELSE hacerlo otro,

604
00:21:00,800 --> 00:21:02,280
pero así es más cómodo,

605
00:21:02,280 --> 00:21:02,560
¿verdad?

606
00:21:02,560 --> 00:21:03,040
Así es más cómodo,

607
00:21:03,040 --> 00:21:04,200
yo hago el retorno,

608
00:21:04,200 --> 00:21:04,600
y ya está,

609
00:21:04,600 --> 00:21:06,680
entonces si he llegado a este punto,

610
00:21:06,680 --> 00:21:07,560
si he llegado a este punto,

611
00:21:07,560 --> 00:21:09,400
es porque no entro aquí,

612
00:21:09,400 --> 00:21:10,080
o lo que es lo mismo,

613
00:21:10,080 --> 00:21:11,760
porque instalada es true,

614
00:21:11,760 --> 00:21:13,560
entonces no hace falta que ponga el ELSE,

615
00:21:13,560 --> 00:21:15,560
no lo hace falta,

616
00:21:15,560 --> 00:21:17,280
¿vale?

617
00:21:17,280 --> 00:21:22,560
Entonces eso es más cómodo.

618
00:21:22,560 --> 00:21:23,560
Y ahora,

619
00:21:23,560 --> 00:21:24,840
¿qué tendríamos que hacer después?

620
00:21:24,840 --> 00:21:26,320
Que ya está instalada,

621
00:21:26,320 --> 00:21:31,520
pues aquí ya lo que tendríamos que hacer es,

622
00:21:31,520 --> 00:21:33,200
comprobar,

623
00:21:33,200 --> 00:21:33,480
bueno,

624
00:21:33,480 --> 00:21:37,160
hacernos la pregunta correspondiente,

625
00:21:37,160 --> 00:21:45,400
¿versión de la instalada menor que la del app,

626
00:21:45,400 --> 00:21:48,480
que la del store,

627
00:21:48,480 --> 00:21:49,880
es menor?

628
00:21:49,880 --> 00:21:53,480
Pues en ese caso sustituimos,

629
00:21:53,480 --> 00:22:04,040
sustituimos la instalada por una copia de la del store,

630
00:22:04,040 --> 00:22:06,920
que es más actual,

631
00:22:06,920 --> 00:22:07,800
y ya está,

632
00:22:07,800 --> 00:22:08,560
y saldríamos,

633
00:22:08,560 --> 00:22:09,200
retorno,

634
00:22:09,200 --> 00:22:09,440
¿vale?

635
00:22:09,440 --> 00:22:11,760
Esto es lo que tendría que hacer el método.

636
00:22:11,760 --> 00:22:12,760
Hemos hecho la primera rama,

637
00:22:12,760 --> 00:22:15,040
¿está instalada o no lo está?

638
00:22:15,040 --> 00:22:17,720
Para eso hemos hecho la estructura de arriba,

639
00:22:17,720 --> 00:22:18,880
de toda la vida,

640
00:22:18,880 --> 00:22:20,360
algo pasa o no pasa,

641
00:22:20,360 --> 00:22:22,600
asumo de partida que no pasa,

642
00:22:22,600 --> 00:22:23,960
y ahora ya recorro,

643
00:22:23,960 --> 00:22:25,600
hago todas las comprobaciones que tenga que hacer,

644
00:22:25,600 --> 00:22:28,880
a ver si alguna de ellas me hace cambiar de idea,

645
00:22:28,880 --> 00:22:31,720
en cuanto una de ellas me haya hecho cambiar de idea,

646
00:22:31,720 --> 00:22:32,520
cambia,

647
00:22:32,520 --> 00:22:34,120
y cuando ese for ya ha terminado,

648
00:22:34,120 --> 00:22:37,280
ya puedo pronunciarme sobre la decisión,

649
00:22:37,280 --> 00:22:38,400
¿vale?

650
00:22:38,400 --> 00:22:40,600
Bueno, pues ese ha sido mi primer if,

651
00:22:40,600 --> 00:22:42,880
y ahora ya,

652
00:22:42,880 --> 00:22:44,200
en el if de que no lo esté,

653
00:22:44,200 --> 00:22:46,080
esto de aquí,

654
00:22:46,080 --> 00:22:48,000
en el if de que sí que lo esté,

655
00:22:48,000 --> 00:22:49,040
ahí se abre otra rama,

656
00:22:49,040 --> 00:22:52,520
una otra pregunta y ya actúa en consecuencia,

657
00:22:52,520 --> 00:22:53,200
¿vale?

658
00:22:53,200 --> 00:22:55,480
Entonces intentemos siempre tener un pensamiento así,

659
00:22:55,480 --> 00:22:56,280
estructurado,

660
00:22:56,280 --> 00:22:57,640
adaptarme a lo que conocemos,

661
00:22:57,640 --> 00:22:59,120
a lo que sabemos,

662
00:22:59,120 --> 00:23:00,200
pues luego ya,

663
00:23:00,200 --> 00:23:02,960
pues luego ya las cosas se pueden ir arreglando y dejando mejor,

664
00:23:02,960 --> 00:23:03,320
¿vale?

665
00:23:03,320 --> 00:23:04,600
Pues por ejemplo,

666
00:23:04,600 --> 00:23:05,720
aquí que este for,

667
00:23:05,720 --> 00:23:07,160
una vez que ha hecho true,

668
00:23:07,160 --> 00:23:08,000
no siga,

669
00:23:08,000 --> 00:23:09,600
pues poniendo ahí una condición,

670
00:23:09,600 --> 00:23:11,720
o un break si me gustan los break,

671
00:23:11,720 --> 00:23:14,160
o sacar esto a un método auxiliar,

672
00:23:14,160 --> 00:23:14,760
que sea,

673
00:23:14,760 --> 00:23:15,760
está instalada,

674
00:23:15,760 --> 00:23:17,840
lo saco a un método auxiliar y lo llamo,

675
00:23:17,840 --> 00:23:20,280
luego ya hay muchas cosas que se pueden hacer,

676
00:23:20,280 --> 00:23:21,560
pero todo eso ya es,

677
00:23:21,560 --> 00:23:23,440
darle a la manivela,

678
00:23:23,440 --> 00:23:23,640
¿vale?

679
00:23:23,640 --> 00:23:25,480
Una vez que uno ya tiene lo básico en la cabeza,

680
00:23:25,480 --> 00:23:26,920
le puede dar a la manivela,

681
00:23:26,920 --> 00:23:28,600
y hacer ya cualquier cosa,

682
00:23:28,600 --> 00:23:29,560
cualquier cosa,

683
00:23:29,560 --> 00:23:31,640
pero siempre teniendo un pensamiento,

684
00:23:31,640 --> 00:23:33,200
de partida ya estructurado,

685
00:23:33,200 --> 00:23:34,520
y bien puesto,

686
00:23:34,520 --> 00:23:37,440
en la cabeza,

687
00:23:37,440 --> 00:23:38,160
¿vale?

688
00:23:38,160 --> 00:23:38,440
Venga,

689
00:23:38,440 --> 00:23:39,760
pues entonces,

690
00:23:39,760 --> 00:23:40,840
instalar la aplicación,

691
00:23:40,840 --> 00:23:41,560
y va a implicar,

692
00:23:41,560 --> 00:23:43,560
ahora ya vamos a pensar en esto,

693
00:23:43,560 --> 00:23:45,080
¿qué tendríamos que hacer?

694
00:23:45,080 --> 00:23:45,440
Bueno,

695
00:23:45,440 --> 00:23:49,760
pues entonces tenemos que,

696
00:23:49,760 --> 00:23:51,600
abrir este array,

697
00:23:51,600 --> 00:23:53,120
una posición más,

698
00:23:53,120 --> 00:23:54,120
una posición más,

699
00:23:54,120 --> 00:23:56,440
abrirle una posición más,

700
00:23:56,440 --> 00:23:58,680
y en esa posición,

701
00:23:58,680 --> 00:24:00,760
llevar una copia,

702
00:24:00,760 --> 00:24:02,840
de la del store,

703
00:24:02,840 --> 00:24:04,560
que se llame así,

704
00:24:04,560 --> 00:24:05,600
pero para eso,

705
00:24:05,600 --> 00:24:07,000
teníamos un método en el store,

706
00:24:07,000 --> 00:24:09,800
que es que ya te sacaba la copia directamente,

707
00:24:09,800 --> 00:24:10,480
que se llamaba install,

708
00:24:10,480 --> 00:24:10,840
¿verdad?

709
00:24:10,840 --> 00:24:13,680
Si yo no recuerdo mal.

710
00:24:13,680 --> 00:24:14,880
Install,

711
00:24:14,880 --> 00:24:17,320
le pasabas el nombre de una aplicación,

712
00:24:17,320 --> 00:24:20,440
y te devolvía una copia,

713
00:24:20,440 --> 00:24:22,760
una copia del objeto aplicación del store,

714
00:24:22,760 --> 00:24:24,920
con ese nombre.

715
00:24:24,920 --> 00:24:25,000
Bueno,

716
00:24:25,000 --> 00:24:26,480
entonces vamos a usar ese método install,

717
00:24:26,480 --> 00:24:28,560
para generar la copia,

718
00:24:28,560 --> 00:24:31,520
que vamos a llevar a la posición adicional,

719
00:24:31,520 --> 00:24:32,560
simplemente,

720
00:24:32,560 --> 00:24:33,960
¿vale?

721
00:24:33,960 --> 00:24:34,240
Bueno,

722
00:24:34,240 --> 00:24:36,560
pues entonces,

723
00:24:36,560 --> 00:24:37,440
aquí,

724
00:24:37,440 --> 00:24:39,320
¿qué tenemos que hacer entonces?

725
00:24:39,320 --> 00:24:40,720
Hemos dicho,

726
00:24:40,720 --> 00:24:43,040
como vamos a instalar una más,

727
00:24:43,040 --> 00:24:43,600
es un rollo,

728
00:24:43,600 --> 00:24:44,360
mientras sea un array,

729
00:24:44,360 --> 00:24:45,080
es un rollo,

730
00:24:45,080 --> 00:24:46,240
tenemos que a mano,

731
00:24:46,240 --> 00:24:48,080
hacer una posición más,

732
00:24:48,080 --> 00:24:48,440
a mano,

733
00:24:48,440 --> 00:24:49,080
hay que hacerla a mano,

734
00:24:49,080 --> 00:24:50,640
porque es un array,

735
00:24:50,640 --> 00:24:51,960
no hay otra.

736
00:24:51,960 --> 00:24:52,240
Bueno,

737
00:24:52,240 --> 00:24:52,720
pues venga,

738
00:24:52,720 --> 00:24:57,840
entonces vamos a hacerlo,

739
00:24:57,840 --> 00:25:00,560
aquí,

740
00:25:00,560 --> 00:25:00,840
¿vale?

741
00:25:01,360 --> 00:25:03,000
Eso tiene que ser siempre,

742
00:25:03,000 --> 00:25:03,920
como un array,

743
00:25:03,920 --> 00:25:05,520
una vez que ya está declarado,

744
00:25:05,520 --> 00:25:07,880
ese array sí o sí es inamovible,

745
00:25:07,880 --> 00:25:10,320
a ese mismo no se le puede expandir,

746
00:25:10,320 --> 00:25:11,920
eso es imposible,

747
00:25:11,920 --> 00:25:13,560
pues eso siempre es de la misma manera,

748
00:25:13,560 --> 00:25:14,960
me tendré que hacer otro,

749
00:25:14,960 --> 00:25:16,360
con una posición más,

750
00:25:16,360 --> 00:25:17,160
copio este en este,

751
00:25:17,160 --> 00:25:17,960
y añado,

752
00:25:17,960 --> 00:25:18,360
¿vale?

753
00:25:18,360 --> 00:25:19,520
Porque lo que sí que es inamovible,

754
00:25:19,520 --> 00:25:20,520
es que un array una vez hecho,

755
00:25:20,520 --> 00:25:22,440
y declarado en memoria a su espacio,

756
00:25:22,440 --> 00:25:23,440
a ese mismo,

757
00:25:23,440 --> 00:25:24,760
no se le puede agrandar,

758
00:25:24,760 --> 00:25:26,640
eso no se puede hacer,

759
00:25:26,640 --> 00:25:27,680
hay que hacer otro,

760
00:25:27,680 --> 00:25:30,480
y sustituir.

761
00:25:30,480 --> 00:25:30,760
Venga,

762
00:25:30,760 --> 00:25:32,680
pues vamos a hacer ese otro,

763
00:25:32,680 --> 00:25:35,480
un array,

764
00:25:35,480 --> 00:25:40,200
de aplicaciones auxiliares,

765
00:25:40,200 --> 00:25:41,400
¿vale?

766
00:25:41,400 --> 00:25:44,560
Que tenga,

767
00:25:44,560 --> 00:25:47,480
el mismo tamaño,

768
00:25:47,480 --> 00:25:48,640
que el de instaladas,

769
00:25:48,640 --> 00:25:54,200
más uno,

770
00:25:54,200 --> 00:25:54,800
ahora,

771
00:25:54,800 --> 00:26:01,800
copiamos uno en el otro,

772
00:26:08,360 --> 00:26:09,520
y ahora ya,

773
00:26:09,520 --> 00:26:11,720
en aux.length,

774
00:26:11,720 --> 00:26:13,040
no perdón,

775
00:26:13,040 --> 00:26:17,600
instaladas.length,

776
00:26:17,600 --> 00:26:21,240
aux de i,

777
00:26:21,240 --> 00:26:26,440
igual a instaladas de i,

778
00:26:26,440 --> 00:26:28,200
y ahora ya en la adicional,

779
00:26:28,200 --> 00:26:30,080
una vez que ya hemos copiado,

780
00:26:30,080 --> 00:26:30,960
la parte común,

781
00:26:30,960 --> 00:26:33,960
en la adicional de aux,

782
00:26:33,960 --> 00:26:35,400
y la adicional de aux,

783
00:26:35,400 --> 00:26:38,880
es aux.length,

784
00:26:38,880 --> 00:26:39,680
menos uno,

785
00:26:39,680 --> 00:26:41,680
esta es su última posición,

786
00:26:41,680 --> 00:26:43,000
la adicional,

787
00:26:43,000 --> 00:26:44,480
pues en esta,

788
00:26:44,480 --> 00:26:46,720
es donde hay que copiar,

789
00:26:46,720 --> 00:26:47,680
una copia,

790
00:26:47,680 --> 00:26:49,240
de la aplicación del store,

791
00:26:49,240 --> 00:26:50,640
que se llame,

792
00:26:50,640 --> 00:26:53,080
con el nombrecito que me han pasado,

793
00:26:53,080 --> 00:26:55,280
pues es que ya tengo un método,

794
00:26:55,280 --> 00:26:57,680
en el store que me hace eso,

795
00:26:57,680 --> 00:26:59,200
ya tenemos un método en el store,

796
00:26:59,200 --> 00:27:01,320
pues entonces,

797
00:27:01,320 --> 00:27:05,440
que era instal,

798
00:27:05,440 --> 00:27:07,120
pues ya está,

799
00:27:07,120 --> 00:27:08,120
¿qué me hacía este método?

800
00:27:08,120 --> 00:27:09,840
Que lo hemos programado antes,

801
00:27:09,840 --> 00:27:11,040
se va al almacén,

802
00:27:11,040 --> 00:27:12,320
que llama al método,

803
00:27:12,320 --> 00:27:13,720
al almacén que llama al método,

804
00:27:13,720 --> 00:27:15,600
en mi caso el almacén del teléfono,

805
00:27:15,600 --> 00:27:16,320
la variable store,

806
00:27:16,320 --> 00:27:18,400
que es el almacén del teléfono,

807
00:27:18,400 --> 00:27:20,600
se va al almacén que llama al método,

808
00:27:20,600 --> 00:27:21,480
busca,

809
00:27:21,480 --> 00:27:24,440
la aplicación que se llama así,

810
00:27:24,440 --> 00:27:25,760
y cuando la ha encontrado,

811
00:27:25,760 --> 00:27:27,800
devuelve una copia,

812
00:27:27,800 --> 00:27:29,440
de esa,

813
00:27:29,440 --> 00:27:30,240
de esa aplicación,

814
00:27:30,240 --> 00:27:31,040
devuelve una copia,

815
00:27:31,040 --> 00:27:32,120
que es justo lo que queremos,

816
00:27:32,120 --> 00:27:34,000
meter una copia ahí,

817
00:27:34,000 --> 00:27:35,840
meter una copia ahí,

818
00:27:35,840 --> 00:27:40,480
¿vale?

819
00:27:40,480 --> 00:27:41,520
Y ahora ya,

820
00:27:41,520 --> 00:27:43,040
pues lo único que tenemos que hacer,

821
00:27:43,040 --> 00:27:44,920
es sustituir,

822
00:27:44,920 --> 00:27:46,520
y que las aplicaciones instaladas,

823
00:27:46,520 --> 00:27:47,240
del móvil,

824
00:27:47,240 --> 00:27:48,920
ahora sean,

825
00:27:48,920 --> 00:27:50,000
las de este array,

826
00:27:50,920 --> 00:27:53,680
auxiliar que acabamos de construir,

827
00:27:53,680 --> 00:27:54,640
las de este array auxiliar,

828
00:27:54,640 --> 00:28:05,440
que acabamos de construir,

829
00:28:05,440 --> 00:28:05,760
vale,

830
00:28:05,760 --> 00:28:07,320
pues instalar la aplicación,

831
00:28:07,320 --> 00:28:09,960
en principio ya está,

832
00:28:09,960 --> 00:28:11,240
aquí ya podríamos,

833
00:28:11,240 --> 00:28:12,440
esto tiene mucho sentido,

834
00:28:12,440 --> 00:28:14,240
y parece así muy bonito,

835
00:28:14,240 --> 00:28:14,760
y todo eso,

836
00:28:14,760 --> 00:28:16,920
en realidad la única parte fea de esta,

837
00:28:16,920 --> 00:28:19,560
es que hemos tenido que hacer este rollo,

838
00:28:19,600 --> 00:28:21,920
porque es un array,

839
00:28:21,920 --> 00:28:22,720
si en lugar de un array,

840
00:28:22,720 --> 00:28:23,600
fuera otra estructura,

841
00:28:23,600 --> 00:28:24,600
se quedaría en una línea,

842
00:28:24,600 --> 00:28:26,200
pero es muy sencillo,

843
00:28:26,200 --> 00:28:28,240
lo que hemos hecho,

844
00:28:28,240 --> 00:28:28,800
lo que pasa es que,

845
00:28:28,800 --> 00:28:29,600
bueno queda muy bonito,

846
00:28:29,600 --> 00:28:30,480
tiene mucho sentido,

847
00:28:30,480 --> 00:28:31,960
pero seguro que algunos,

848
00:28:31,960 --> 00:28:32,920
ya podríais adivinar,

849
00:28:32,920 --> 00:28:33,600
que esto no va a pasar,

850
00:28:33,600 --> 00:28:35,200
la fase de pruebas,

851
00:28:35,200 --> 00:28:38,800
¿verdad que no?

852
00:28:38,800 --> 00:28:39,520
¿Por qué no va a pasar,

853
00:28:39,520 --> 00:28:40,280
la fase de pruebas,

854
00:28:40,280 --> 00:28:46,640
ya directamente en la primera prueba?

855
00:28:46,640 --> 00:28:47,200
¿Qué va a pasar,

856
00:28:47,200 --> 00:28:48,680
cuando tratemos de instalar,

857
00:28:48,720 --> 00:28:50,480
la primera de las aplicaciones,

858
00:28:50,480 --> 00:28:52,440
en el móvil,

859
00:28:52,440 --> 00:28:53,200
la primera de todas,

860
00:28:53,200 --> 00:28:54,320
yo acabo de arrancar mi móvil,

861
00:28:54,320 --> 00:28:55,360
lo he construido,

862
00:28:55,360 --> 00:29:03,360
voy a instalarle la primera,

863
00:29:03,360 --> 00:29:04,680
si lo de siempre,

864
00:29:04,680 --> 00:29:09,080
¿por qué?

865
00:29:09,080 --> 00:29:13,560
¿Por qué?

866
00:29:13,560 --> 00:29:14,360
Claro,

867
00:29:14,360 --> 00:29:15,480
porque si es la primera,

868
00:29:15,480 --> 00:29:16,160
que yo instalo,

869
00:29:16,160 --> 00:29:18,040
acabo de arrancar mi teléfono,

870
00:29:18,040 --> 00:29:19,240
que la RAI instaladas,

871
00:29:19,240 --> 00:29:21,240
es nul todavía,

872
00:29:21,240 --> 00:29:24,040
es nul todavía,

873
00:29:24,040 --> 00:29:25,120
entonces si es la,

874
00:29:25,120 --> 00:29:26,760
por eso siempre distinguimos,

875
00:29:26,760 --> 00:29:27,800
oye,

876
00:29:27,800 --> 00:29:29,440
es la primera que metes,

877
00:29:29,440 --> 00:29:31,520
es la primera,

878
00:29:31,520 --> 00:29:34,560
¿vale?

879
00:29:34,560 --> 00:29:34,880
Entonces,

880
00:29:34,880 --> 00:29:35,480
en lugar de,

881
00:29:35,480 --> 00:29:36,440
como ahora ya,

882
00:29:36,440 --> 00:29:37,440
lo manejamos todo,

883
00:29:37,440 --> 00:29:38,160
tenemos un montón de cosas,

884
00:29:38,160 --> 00:29:39,000
en la cabeza,

885
00:29:39,000 --> 00:29:39,880
lo controlamos todo,

886
00:29:39,880 --> 00:29:41,480
ya empezamos a estar más sueltos,

887
00:29:41,480 --> 00:29:43,240
en lugar de arreglar ese error,

888
00:29:43,240 --> 00:29:45,560
que ya prevemos,

889
00:29:45,560 --> 00:29:46,520
¿verdad?

890
00:29:46,760 --> 00:29:49,880
Lo que digo nos desconcierta,

891
00:29:49,880 --> 00:29:50,920
¿no?

892
00:29:50,920 --> 00:29:51,120
Pues,

893
00:29:51,120 --> 00:29:52,400
en lugar de arreglar el error,

894
00:29:52,400 --> 00:29:53,160
viene de aquí, ¿no?

895
00:29:53,160 --> 00:29:54,080
Que el móvil,

896
00:29:54,080 --> 00:29:55,440
cuando se,

897
00:29:55,440 --> 00:29:58,600
yo inicialice por primera vez,

898
00:29:58,600 --> 00:30:01,000
este ARRAI es nul.

899
00:30:01,000 --> 00:30:01,200
Entonces,

900
00:30:01,200 --> 00:30:02,640
eso va a ser nul,

901
00:30:02,640 --> 00:30:04,440
y cuando yo llame a get up,

902
00:30:04,440 --> 00:30:06,880
por primera vez,

903
00:30:06,880 --> 00:30:07,760
cuando llame a get up,

904
00:30:07,760 --> 00:30:08,480
por primera vez,

905
00:30:08,480 --> 00:30:10,360
en cuanto salte a instaladas,

906
00:30:10,360 --> 00:30:11,320
punto length,

907
00:30:11,320 --> 00:30:12,680
ahí en el punto length,

908
00:30:12,680 --> 00:30:13,640
es cuando va a decir,

909
00:30:13,640 --> 00:30:14,560
nul point exception,

910
00:30:14,560 --> 00:30:15,320
porque algo que es nul,

911
00:30:15,320 --> 00:30:16,760
no puedes hacer punto lo que sea,

912
00:30:16,760 --> 00:30:18,760
porque es nul.

913
00:30:18,760 --> 00:30:21,160
Vale, pues, entonces,

914
00:30:21,160 --> 00:30:22,680
eso como lo hemos arreglado otras

915
00:30:22,680 --> 00:30:23,520
veces,

916
00:30:23,520 --> 00:30:25,680
pues, hemos distinguido aquí,

917
00:30:25,680 --> 00:30:27,160
hemos distinguido,

918
00:30:27,160 --> 00:30:28,200
aquí, perdón,

919
00:30:28,200 --> 00:30:29,000
hemos distinguido,

920
00:30:29,000 --> 00:30:31,400
if instaladas igual a nul.

921
00:30:31,400 --> 00:30:31,760
Entonces,

922
00:30:31,760 --> 00:30:33,320
crea instaladas con un espacio y

923
00:30:33,320 --> 00:30:35,560
lo haces, ¿vale?

924
00:30:35,560 --> 00:30:36,160
Pero,

925
00:30:36,160 --> 00:30:38,560
como ya sabemos,

926
00:30:38,560 --> 00:30:39,760
lo entendemos todo de fondo,

927
00:30:39,760 --> 00:30:40,640
vamos a arreglarlo de otra manera

928
00:30:40,640 --> 00:30:41,840
distinta,

929
00:30:41,840 --> 00:30:43,080
para variar.

930
00:30:43,080 --> 00:30:43,840
Vamos a arreglarlo de otra manera

931
00:30:43,840 --> 00:30:46,680
distinta.

932
00:30:46,680 --> 00:30:49,320
Y es, oye,

933
00:30:49,320 --> 00:30:49,640
pues,

934
00:30:49,640 --> 00:30:51,600
cuando el móvil arranca,

935
00:30:51,600 --> 00:30:52,840
le voy a dar yo ya un valor

936
00:30:52,840 --> 00:30:54,400
inicial a esto,

937
00:30:54,400 --> 00:30:55,520
le voy a dar yo ya un valor

938
00:30:55,520 --> 00:30:56,920
inicial para que no sea nul,

939
00:30:56,920 --> 00:30:58,360
para asegurarme de que no es nul

940
00:30:58,360 --> 00:30:59,320
en el momento en que el móvil

941
00:30:59,320 --> 00:31:02,080
arranque,

942
00:31:02,080 --> 00:31:03,320
porque siempre se puede hacer eso,

943
00:31:03,320 --> 00:31:04,240
¿no?

944
00:31:04,240 --> 00:31:06,560
Las propiedades de una clase,

945
00:31:06,560 --> 00:31:08,640
tú les das un valor inicial y eso

946
00:31:08,640 --> 00:31:10,640
significa que cuando crees un

947
00:31:10,640 --> 00:31:12,600
objeto de esa clase,

948
00:31:12,600 --> 00:31:13,640
se creará espacio para las

949
00:31:13,640 --> 00:31:14,240
propiedades,

950
00:31:14,240 --> 00:31:16,120
se le dará el valor inicial y

951
00:31:16,120 --> 00:31:16,840
luego ya se ejecutará el

952
00:31:16,840 --> 00:31:19,160
constructor.

953
00:31:19,160 --> 00:31:19,760
Vale.

954
00:31:19,760 --> 00:31:20,840
Pues,

955
00:31:20,840 --> 00:31:22,800
vamos a darle un valor inicial,

956
00:31:22,800 --> 00:31:24,320
como es un array,

957
00:31:24,320 --> 00:31:24,560
pues,

958
00:31:24,560 --> 00:31:26,680
hay que darle algo de tipo

959
00:31:26,680 --> 00:31:26,960
array,

960
00:31:26,960 --> 00:31:28,320
no hay otra.

961
00:31:28,320 --> 00:31:29,360
Y la pregunta sería,

962
00:31:29,360 --> 00:31:29,520
uy,

963
00:31:29,520 --> 00:31:29,680
ya,

964
00:31:29,680 --> 00:31:31,400
pero cuántas posiciones le doy.

965
00:31:31,400 --> 00:31:32,280
Yo quiero darle,

966
00:31:32,280 --> 00:31:33,840
quiero que ese array inicialmente

967
00:31:33,840 --> 00:31:35,080
no sea nul,

968
00:31:35,080 --> 00:31:36,280
que se haya una dirección a algún

969
00:31:36,280 --> 00:31:37,320
sitio,

970
00:31:37,320 --> 00:31:40,080
pero cuántas posiciones le doy.

971
00:31:40,080 --> 00:31:40,320
Pues,

972
00:31:40,320 --> 00:31:40,640
es que no,

973
00:31:40,640 --> 00:31:41,440
ahora mismo,

974
00:31:41,440 --> 00:31:43,200
recién abierto el móvil,

975
00:31:43,200 --> 00:31:44,840
es que no tiene ninguna instalada.

976
00:31:44,840 --> 00:31:44,960
Pues,

977
00:31:44,960 --> 00:31:45,440
no pasa nada,

978
00:31:45,440 --> 00:31:46,400
le ponemos cero.

979
00:31:46,400 --> 00:31:47,880
Esto se puede hacer.

980
00:31:47,880 --> 00:31:48,400
Ya lo habéis hecho,

981
00:31:48,400 --> 00:31:48,640
de hecho,

982
00:31:48,640 --> 00:31:50,000
con Estefán alguna vez.

983
00:31:50,000 --> 00:31:51,200
No pasa nada.

984
00:31:51,200 --> 00:31:52,040
Esto se puede hacer,

985
00:31:52,040 --> 00:31:53,680
se puede instanciar un array de

986
00:31:53,680 --> 00:31:55,360
cero posiciones.

987
00:31:55,360 --> 00:31:57,200
Y esto ya no es nul.

988
00:31:57,200 --> 00:31:58,160
No es lo mismo nul,

989
00:31:58,160 --> 00:32:00,000
que significa la dirección a la

990
00:32:00,000 --> 00:32:01,080
nada,

991
00:32:01,080 --> 00:32:01,560
o esto,

992
00:32:01,560 --> 00:32:05,360
que significa apunto a una zona

993
00:32:05,360 --> 00:32:08,120
para un array de cero posiciones.

994
00:32:08,120 --> 00:32:09,520
No es lo mismo.

995
00:32:09,520 --> 00:32:10,960
Esto ya no es nul.

996
00:32:10,960 --> 00:32:12,400
¿Vale?

997
00:32:12,400 --> 00:32:12,680
Entonces,

998
00:32:12,680 --> 00:32:13,800
es otra forma de arreglarlo.

999
00:32:13,800 --> 00:32:14,040
Entonces,

1000
00:32:14,040 --> 00:32:15,240
acostumbrémonos a todo.

1001
00:32:15,240 --> 00:32:15,960
Ahí,

1002
00:32:15,960 --> 00:32:16,880
con lo que lo entendamos,

1003
00:32:16,880 --> 00:32:17,160
todo.

1004
00:32:17,160 --> 00:32:18,520
Y los vamos a usar todo.

1005
00:32:18,520 --> 00:32:18,840
¿Vale?

1006
00:32:18,840 --> 00:32:19,000
Pues,

1007
00:32:19,000 --> 00:32:19,520
entonces,

1008
00:32:19,520 --> 00:32:20,840
cada vez que un móvil arranque,

1009
00:32:20,840 --> 00:32:22,360
se va a inicializar con un array

1010
00:32:22,360 --> 00:32:24,000
de instaladas de cero posiciones

1011
00:32:24,000 --> 00:32:24,640
todavía.

1012
00:32:24,640 --> 00:32:27,040
Pero ya no va a ser nul ese array.

1013
00:32:27,040 --> 00:32:27,320
Eso,

1014
00:32:27,320 --> 00:32:29,800
la implicación que tiene,

1015
00:32:29,800 --> 00:32:31,280
es que ya lo de aquí abajo ya sí

1016
00:32:31,280 --> 00:32:32,800
que va a funcionar.

1017
00:32:32,800 --> 00:32:34,200
Y no me va a dar un null pointer

1018
00:32:34,200 --> 00:32:35,560
exception.

1019
00:32:35,560 --> 00:32:39,120
Porque ahora ya,

1020
00:32:40,000 --> 00:32:42,520
el instaladas punto length,

1021
00:32:42,520 --> 00:32:44,760
me va a decir cero.

1022
00:32:44,760 --> 00:32:45,840
¿Vale?

1023
00:32:45,840 --> 00:32:47,520
Si el array está sin inicializar,

1024
00:32:47,520 --> 00:32:48,880
instaladas es null.

1025
00:32:48,880 --> 00:32:49,680
Luego,

1026
00:32:49,680 --> 00:32:51,320
null punto length es null pointer

1027
00:32:51,320 --> 00:32:52,560
excepción.

1028
00:32:52,560 --> 00:32:55,720
Pero si instaladas es new app cero,

1029
00:32:55,720 --> 00:32:56,280
no es null,

1030
00:32:56,280 --> 00:32:57,040
va a poder llamar.

1031
00:32:57,040 --> 00:32:58,160
¿Y qué va a devolver length?

1032
00:32:58,160 --> 00:32:58,320
Pues,

1033
00:32:58,320 --> 00:32:59,000
cero.

1034
00:32:59,000 --> 00:32:59,440
No pasa nada,

1035
00:32:59,440 --> 00:33:00,600
devuelve cero.

1036
00:33:00,600 --> 00:33:01,440
Y al devolver cero,

1037
00:33:01,440 --> 00:33:02,080
¿qué va a ocurrir?

1038
00:33:02,080 --> 00:33:03,160
Que nunca jamás va a entrar en

1039
00:33:03,160 --> 00:33:03,880
este array,

1040
00:33:03,880 --> 00:33:04,520
lógicamente,

1041
00:33:04,520 --> 00:33:05,520
pero es que no queremos que entre,

1042
00:33:05,520 --> 00:33:06,600
porque es que no va a estar

1043
00:33:06,600 --> 00:33:07,920
instalada.

1044
00:33:07,920 --> 00:33:08,200
Entonces,

1045
00:33:08,200 --> 00:33:09,600
va a devolver cero.

1046
00:33:09,600 --> 00:33:11,680
Y aquí también va a devolver cero.

1047
00:33:11,680 --> 00:33:12,120
Con lo cual,

1048
00:33:12,120 --> 00:33:13,040
al devolver cero,

1049
00:33:13,040 --> 00:33:15,640
el auxiliar se va a inicializar

1050
00:33:15,640 --> 00:33:17,040
con una posición,

1051
00:33:17,040 --> 00:33:18,160
que es justo lo que queremos,

1052
00:33:18,160 --> 00:33:19,240
con una.

1053
00:33:19,240 --> 00:33:20,400
¿Vale?

1054
00:33:20,400 --> 00:33:20,720
Entonces,

1055
00:33:20,720 --> 00:33:23,200
esa es una forma de arreglarlo

1056
00:33:23,200 --> 00:33:24,880
más cómoda.

1057
00:33:24,880 --> 00:33:25,120
¿Vale?

1058
00:33:25,120 --> 00:33:26,720
Siempre y cuando tenga yo la

1059
00:33:26,720 --> 00:33:29,800
opción de ir a la variable a

1060
00:33:29,800 --> 00:33:31,560
inicializarla.

1061
00:33:31,560 --> 00:33:32,320
Que puede haber situaciones en

1062
00:33:32,320 --> 00:33:33,360
las que no lo tenga.

1063
00:33:33,360 --> 00:33:33,960
Si no lo tengo,

1064
00:33:33,960 --> 00:33:34,920
tendremos que hacerlo como hemos

1065
00:33:34,920 --> 00:33:35,640
hecho hasta ahora,

1066
00:33:35,640 --> 00:33:37,320
distinguir y darle.

1067
00:33:37,320 --> 00:33:38,440
Pero si tengo yo la opción de

1068
00:33:38,440 --> 00:33:39,280
ir a la zona donde le he

1069
00:33:39,280 --> 00:33:40,280
declarado inicializarla,

1070
00:33:40,280 --> 00:33:44,240
inicializa cero y listo.

1071
00:33:44,240 --> 00:33:45,000
¿Vale?

1072
00:33:45,000 --> 00:33:45,240
Bueno,

1073
00:33:45,240 --> 00:33:45,400
pues,

1074
00:33:45,400 --> 00:33:45,760
entonces,

1075
00:33:45,760 --> 00:33:49,160
esto ya no nos va a dar null

1076
00:33:49,160 --> 00:33:50,160
pointer exception.

1077
00:33:50,160 --> 00:33:52,400
Esto nos va a dar cero.

1078
00:33:52,400 --> 00:33:54,040
Y esto nos va a dar cero cuando

1079
00:33:54,040 --> 00:33:55,240
sea la primera de todas,

1080
00:33:55,240 --> 00:33:56,360
claro.

1081
00:33:56,360 --> 00:33:56,920
Vale, pues,

1082
00:33:56,920 --> 00:33:57,280
ya está.

1083
00:33:57,280 --> 00:33:58,080
Que la aplicación no esté

1084
00:33:58,080 --> 00:33:58,680
instalada,

1085
00:33:58,680 --> 00:33:59,520
hemos acabado.

1086
00:33:59,520 --> 00:34:00,000
Retune,

1087
00:34:00,000 --> 00:34:00,320
fuera,

1088
00:34:00,320 --> 00:34:01,360
hemos acabado.

1089
00:34:01,360 --> 00:34:02,040
Y ahora,

1090
00:34:02,040 --> 00:34:05,920
¿qué pasa si está instalada?

1091
00:34:05,920 --> 00:34:06,440
Dime.

1092
00:34:12,160 --> 00:34:15,080
El retune sale del método.

1093
00:34:15,080 --> 00:34:17,800
El break asócialo a bucles.

1094
00:34:17,800 --> 00:34:17,920
O sea,

1095
00:34:17,920 --> 00:34:19,240
el break sale de bucles.

1096
00:34:19,240 --> 00:34:20,040
Sale de while,

1097
00:34:20,040 --> 00:34:21,560
sale de for.

1098
00:34:21,560 --> 00:34:22,120
¿Vale?

1099
00:34:22,120 --> 00:34:23,600
Pero el retune está asociado,

1100
00:34:23,600 --> 00:34:24,440
tiene que estar siempre dentro

1101
00:34:24,440 --> 00:34:25,440
de un método.

1102
00:34:25,440 --> 00:34:25,720
Entonces,

1103
00:34:25,720 --> 00:34:27,400
el retune sale del método.

1104
00:34:27,400 --> 00:34:29,200
Que además está dentro de un

1105
00:34:29,200 --> 00:34:30,200
for también saldría.

1106
00:34:30,200 --> 00:34:30,360
O sea,

1107
00:34:30,360 --> 00:34:31,800
es que directamente el retune

1108
00:34:31,800 --> 00:34:34,840
abandona el método y se va a la

1109
00:34:34,840 --> 00:34:36,720
siguiente línea desde la que se

1110
00:34:36,720 --> 00:34:37,480
llamó al método.

1111
00:34:37,480 --> 00:34:37,800
O sea,

1112
00:34:37,800 --> 00:34:39,640
abandona el método directamente.

1113
00:34:39,640 --> 00:34:41,080
El break simplemente sale del

1114
00:34:41,080 --> 00:34:42,280
bucle en el que esté.

1115
00:34:42,280 --> 00:34:43,160
Si está dentro de un for,

1116
00:34:43,160 --> 00:34:43,720
sale del for,

1117
00:34:43,720 --> 00:34:45,600
pero sigue por debajo del for.

1118
00:34:45,600 --> 00:34:45,760
O sea,

1119
00:34:45,760 --> 00:34:47,000
tú tienes un for con un break

1120
00:34:47,000 --> 00:34:47,280
dentro.

1121
00:34:47,280 --> 00:34:48,320
Tienes que tener el mismo cuidado

1122
00:34:48,320 --> 00:34:51,200
con poner una cosa y la otra.

1123
00:34:51,200 --> 00:34:51,400
Digo,

1124
00:34:51,400 --> 00:34:53,240
porque lo que puede ocurrir con

1125
00:34:53,240 --> 00:34:54,480
un break,

1126
00:34:54,480 --> 00:34:56,480
si lo pones en un bucle,

1127
00:34:56,480 --> 00:34:58,480
a lo mejor te interesa.

1128
00:34:58,480 --> 00:34:58,680
Bueno,

1129
00:34:58,680 --> 00:34:58,880
a ver,

1130
00:34:58,880 --> 00:34:59,040
o sea,

1131
00:34:59,040 --> 00:35:00,080
el problema del break,

1132
00:35:00,080 --> 00:35:00,280
o sea,

1133
00:35:00,280 --> 00:35:02,120
no es tanto lo que puede ocurrir,

1134
00:35:02,120 --> 00:35:03,200
sino la legibilidad.

1135
00:35:03,200 --> 00:35:04,320
El problema que lo haga más

1136
00:35:04,320 --> 00:35:05,400
ilegible,

1137
00:35:05,400 --> 00:35:06,720
porque uno está leyendo el código

1138
00:35:06,720 --> 00:35:08,200
y ve el break y dice,

1139
00:35:08,200 --> 00:35:08,640
oye,

1140
00:35:08,640 --> 00:35:09,880
¿y aquí por qué ha salido?

1141
00:35:09,880 --> 00:35:10,120
Entonces,

1142
00:35:10,120 --> 00:35:11,240
te tienes que ir,

1143
00:35:11,240 --> 00:35:12,680
tienes que entender todo el código

1144
00:35:12,680 --> 00:35:13,360
para ver por qué.

1145
00:35:13,360 --> 00:35:13,680
Entonces,

1146
00:35:13,680 --> 00:35:14,320
por eso,

1147
00:35:14,320 --> 00:35:15,480
es por lo que decimos que siempre

1148
00:35:15,480 --> 00:35:17,640
es mejor salir de los bucles

1149
00:35:17,640 --> 00:35:18,880
poniendo la condición arriba.

1150
00:35:18,880 --> 00:35:19,880
Porque el que está leyendo el

1151
00:35:19,880 --> 00:35:20,720
código,

1152
00:35:20,720 --> 00:35:22,320
al ver la condición expresada,

1153
00:35:22,320 --> 00:35:24,160
entiende en qué situaciones vas a

1154
00:35:24,160 --> 00:35:25,440
salir y en cuáles no.

1155
00:35:25,440 --> 00:35:26,480
El break no te dice,

1156
00:35:26,480 --> 00:35:28,120
es algo porque ha pasado esto,

1157
00:35:28,120 --> 00:35:29,200
te dice break.

1158
00:35:29,200 --> 00:35:29,840
Entonces,

1159
00:35:29,840 --> 00:35:31,640
lo de que sea desaconsejable es

1160
00:35:31,640 --> 00:35:33,400
por un tema de que lo hace más

1161
00:35:33,440 --> 00:35:34,160
ilegible.

1162
00:35:34,160 --> 00:35:34,440
Más.

1163
00:35:34,440 --> 00:35:36,120
¿Cuando el return primero cumple

1164
00:35:36,120 --> 00:35:38,520
la condición que tú lo pongas?

1165
00:35:38,520 --> 00:35:40,760
El return abandona el método en

1166
00:35:40,760 --> 00:35:41,320
el que estés.

1167
00:35:41,320 --> 00:35:41,440
O sea,

1168
00:35:41,440 --> 00:35:42,480
la diferencia entre cómo

1169
00:35:42,480 --> 00:35:43,960
funciona está clara, ¿no?

1170
00:35:43,960 --> 00:35:44,960
El break, o sea,

1171
00:35:44,960 --> 00:35:46,320
tú tienes un método con un for

1172
00:35:46,320 --> 00:35:48,560
dentro.

1173
00:35:48,560 --> 00:35:50,480
Digamos que no cumple el límite

1174
00:35:50,480 --> 00:35:51,400
de la condición.

1175
00:35:51,400 --> 00:35:51,840
Claro, o sea,

1176
00:35:51,840 --> 00:35:52,280
tú tienes,

1177
00:35:52,280 --> 00:35:52,920
yo tengo aquí un break.

1178
00:35:52,920 --> 00:35:54,280
Parte en cuanto encuentra lo que

1179
00:35:54,280 --> 00:35:57,280
tú has puesto en la condición.

1180
00:35:57,280 --> 00:35:57,800
¿Repite?

1181
00:35:57,800 --> 00:36:00,200
Sale en cuanto encuentra un

1182
00:36:00,200 --> 00:36:00,840
resultado.

1183
00:36:00,840 --> 00:36:01,240
El break,

1184
00:36:01,240 --> 00:36:01,760
dices.

1185
00:36:01,760 --> 00:36:02,280
Sí.

1186
00:36:02,280 --> 00:36:02,400
No,

1187
00:36:02,400 --> 00:36:03,360
el break sale en cuanto llegues

1188
00:36:03,360 --> 00:36:03,880
a él.

1189
00:36:03,880 --> 00:36:04,080
O sea,

1190
00:36:04,080 --> 00:36:05,240
de repente la máquina virtual

1191
00:36:05,240 --> 00:36:06,080
llega a un break.

1192
00:36:06,080 --> 00:36:06,600
Llega a un break,

1193
00:36:06,600 --> 00:36:07,400
yo tengo aquí un break,

1194
00:36:07,400 --> 00:36:07,960
por ejemplo,

1195
00:36:07,960 --> 00:36:08,080
pues,

1196
00:36:08,080 --> 00:36:08,880
entonces,

1197
00:36:08,880 --> 00:36:10,360
directamente el break no es que

1198
00:36:10,360 --> 00:36:11,360
mire condiciones y nada.

1199
00:36:11,360 --> 00:36:13,000
El break directamente sale del

1200
00:36:13,000 --> 00:36:13,760
bucle en el que esté.

1201
00:36:13,760 --> 00:36:15,320
Sale.

1202
00:36:15,320 --> 00:36:15,560
O sea,

1203
00:36:15,560 --> 00:36:17,280
el break significa sal del bucle.

1204
00:36:17,280 --> 00:36:18,200
Ni miras condiciones ni miras

1205
00:36:18,200 --> 00:36:18,440
nada,

1206
00:36:18,440 --> 00:36:19,920
pero solo de ese bucle,

1207
00:36:19,920 --> 00:36:21,600
pero solo de ese bucle.

1208
00:36:21,600 --> 00:36:22,280
Entonces,

1209
00:36:22,280 --> 00:36:23,520
la diferencia entre poner aquí un

1210
00:36:23,520 --> 00:36:24,240
break y un return,

1211
00:36:24,240 --> 00:36:27,800
imagínate que yo tengo aquí,

1212
00:36:27,800 --> 00:36:28,640
¿vale?

1213
00:36:28,640 --> 00:36:31,320
Tengo aquí un break.

1214
00:36:34,240 --> 00:36:34,640
El break,

1215
00:36:34,640 --> 00:36:35,560
está acá lo que haría.

1216
00:36:35,560 --> 00:36:36,960
Al llegar aquí,

1217
00:36:36,960 --> 00:36:38,760
el break sale del bucle en el

1218
00:36:38,760 --> 00:36:39,360
que estás.

1219
00:36:39,360 --> 00:36:40,400
¿En qué bucle estás?

1220
00:36:40,400 --> 00:36:41,440
En el for.

1221
00:36:41,440 --> 00:36:42,360
Sale.

1222
00:36:42,360 --> 00:36:43,400
Allá pasa lo que haya pasado,

1223
00:36:43,400 --> 00:36:44,240
ni mira condiciones ni mira

1224
00:36:44,240 --> 00:36:44,760
nada.

1225
00:36:44,760 --> 00:36:46,520
Cuando uno llega al break,

1226
00:36:46,520 --> 00:36:46,840
fuera,

1227
00:36:46,840 --> 00:36:47,520
se acabó el bucle.

1228
00:36:47,520 --> 00:36:47,800
Entonces,

1229
00:36:47,800 --> 00:36:49,680
continuarías por aquí.

1230
00:36:49,680 --> 00:36:51,640
Pero el programa sigue,

1231
00:36:51,640 --> 00:36:52,840
pero sigue por ahí.

1232
00:36:52,840 --> 00:36:53,680
¿Qué pasa si yo pongo un

1233
00:36:53,680 --> 00:36:55,720
return?

1234
00:36:55,720 --> 00:36:57,200
El return lo que hace es,

1235
00:36:57,200 --> 00:36:58,960
sales del método directamente.

1236
00:36:58,960 --> 00:37:00,520
Es que ya no haces nada más.

1237
00:37:00,520 --> 00:37:02,040
El método se acabó.

1238
00:37:02,040 --> 00:37:02,520
Sales.

1239
00:37:02,520 --> 00:37:04,160
El método terminado.

1240
00:37:04,160 --> 00:37:04,440
Entonces,

1241
00:37:04,440 --> 00:37:06,200
del break sales del bucle en el

1242
00:37:06,200 --> 00:37:06,880
que estás metido,

1243
00:37:06,880 --> 00:37:08,560
pero continúas por abajo.

1244
00:37:08,560 --> 00:37:09,840
Y el return significa,

1245
00:37:09,840 --> 00:37:10,840
ya no hay más que hacer.

1246
00:37:10,840 --> 00:37:12,080
El método se acabó.

1247
00:37:12,080 --> 00:37:13,680
Ya no hay más.

1248
00:37:13,680 --> 00:37:15,560
¿Vale?

1249
00:37:15,560 --> 00:37:15,920
Entonces,

1250
00:37:15,920 --> 00:37:17,160
sí que es cierto también que

1251
00:37:17,160 --> 00:37:17,680
puede,

1252
00:37:17,680 --> 00:37:19,320
que el return,

1253
00:37:19,320 --> 00:37:20,760
abusar de ellos,

1254
00:37:20,760 --> 00:37:20,960
pues,

1255
00:37:20,960 --> 00:37:22,400
puede hacer un poquito,

1256
00:37:22,400 --> 00:37:22,720
a lo mejor,

1257
00:37:22,720 --> 00:37:24,000
ilegible el código.

1258
00:37:24,000 --> 00:37:25,840
Porque si tú ves mucho return,

1259
00:37:25,840 --> 00:37:26,760
claro,

1260
00:37:26,760 --> 00:37:27,640
¿vale?

1261
00:37:27,640 --> 00:37:28,640
Pero es que con el return

1262
00:37:28,640 --> 00:37:30,040
también tienes mucho que ganar

1263
00:37:30,040 --> 00:37:31,120
porque,

1264
00:37:31,120 --> 00:37:31,920
a su vez,

1265
00:37:31,920 --> 00:37:35,320
te ahorras los saleses.

1266
00:37:35,320 --> 00:37:35,600
Entonces,

1267
00:37:35,600 --> 00:37:37,240
al ahorrarte los saleses,

1268
00:37:37,240 --> 00:37:38,440
a veces también te lo puede hacer

1269
00:37:38,440 --> 00:37:39,280
más legible.

1270
00:37:39,280 --> 00:37:39,600
Entonces,

1271
00:37:39,600 --> 00:37:40,520
el return,

1272
00:37:40,520 --> 00:37:40,840
pues, bueno,

1273
00:37:40,840 --> 00:37:41,800
es un poquito el equilibrio

1274
00:37:41,800 --> 00:37:42,680
dependiendo de.

1275
00:37:46,040 --> 00:37:46,640
Entonces,

1276
00:37:46,640 --> 00:37:48,480
en nuestro caso no queremos,

1277
00:37:48,480 --> 00:37:49,840
no ponemos ni return ni break por

1278
00:37:49,840 --> 00:37:50,600
ahora y ya está.

1279
00:37:53,320 --> 00:37:53,560
¿Vale?

1280
00:37:53,560 --> 00:37:54,160
Entonces,

1281
00:37:54,160 --> 00:37:55,080
si no está instalada,

1282
00:37:55,080 --> 00:37:55,880
la instalamos.

1283
00:37:55,880 --> 00:37:56,280
Y ahora,

1284
00:37:56,280 --> 00:37:58,000
estábamos aquí.

1285
00:37:58,000 --> 00:37:59,200
Sí está instalada.

1286
00:37:59,200 --> 00:37:59,760
Sí está.

1287
00:37:59,760 --> 00:38:01,800
Hemos llegado ahí.

1288
00:38:01,800 --> 00:38:03,160
Esto sería como si no pusiéramos

1289
00:38:03,160 --> 00:38:03,640
return,

1290
00:38:03,640 --> 00:38:04,800
aquí tendría que haber un ELSE.

1291
00:38:04,800 --> 00:38:06,200
Eso está claro, ¿no?

1292
00:38:06,200 --> 00:38:07,480
Si yo no pongo el return,

1293
00:38:07,480 --> 00:38:08,840
aquí tiene que haber un ELSE.

1294
00:38:08,840 --> 00:38:09,400
Entonces,

1295
00:38:09,400 --> 00:38:10,440
el poner el return me ahorra el

1296
00:38:10,440 --> 00:38:10,800
ELSE.

1297
00:38:10,800 --> 00:38:12,120
Es un tema de comodidad,

1298
00:38:12,120 --> 00:38:13,400
en realidad.

1299
00:38:13,400 --> 00:38:14,040
¿Vale?

1300
00:38:14,040 --> 00:38:15,040
Que he llegado ahí,

1301
00:38:15,040 --> 00:38:15,760
que he llegado aquí,

1302
00:38:15,760 --> 00:38:16,720
si he llegado aquí,

1303
00:38:16,720 --> 00:38:18,760
es porque la aplicación estaba

1304
00:38:18,760 --> 00:38:19,480
ya instalada.

1305
00:38:19,480 --> 00:38:19,880
Estaba.

1306
00:38:19,880 --> 00:38:20,320
Porque si no,

1307
00:38:20,320 --> 00:38:22,040
habría salido por ahí arriba.

1308
00:38:22,040 --> 00:38:22,280
¿Vale?

1309
00:38:22,280 --> 00:38:22,480
Pues,

1310
00:38:22,480 --> 00:38:22,760
si está,

1311
00:38:22,760 --> 00:38:24,400
¿qué es lo que tenemos que hacer?

1312
00:38:24,400 --> 00:38:29,880
Comprobar su versión.

1313
00:38:29,880 --> 00:38:30,440
¿Vale?

1314
00:38:30,440 --> 00:38:31,160
Entonces,

1315
00:38:31,160 --> 00:38:33,480
comprobar la versión de la

1316
00:38:33,480 --> 00:38:36,600
aplicación que se llame así,

1317
00:38:36,600 --> 00:38:39,480
dentro de las instaladas.

1318
00:38:39,480 --> 00:38:40,040
Entonces,

1319
00:38:40,040 --> 00:38:42,440
¿tenemos algún método hecho por

1320
00:38:42,440 --> 00:38:43,600
aquí que me devuelva la

1321
00:38:43,600 --> 00:38:46,000
aplicación que tengo yo

1322
00:38:46,000 --> 00:38:46,680
instaladas?

1323
00:38:46,680 --> 00:38:47,240
No,

1324
00:38:47,240 --> 00:38:48,000
no tenemos ninguno.

1325
00:38:48,000 --> 00:38:48,320
Entonces,

1326
00:38:48,320 --> 00:38:50,760
tendríamos que recorrer las

1327
00:38:50,760 --> 00:38:52,600
instaladas hasta que la

1328
00:38:52,720 --> 00:38:56,160
encontremos,

1329
00:38:56,160 --> 00:38:57,120
recorrer las instaladas hasta

1330
00:38:57,120 --> 00:38:58,400
que la encontremos,

1331
00:38:58,400 --> 00:38:59,880
a ver cuál es su versión.

1332
00:38:59,880 --> 00:39:00,840
Por ejemplo,

1333
00:39:00,840 --> 00:39:05,560
la int versión instalada.

1334
00:39:08,040 --> 00:39:08,600
¿Vale?

1335
00:39:13,400 --> 00:39:15,720
Y ahora podemos recorrer por

1336
00:39:15,720 --> 00:39:24,640
int y,

1337
00:39:24,640 --> 00:39:25,000
bueno,

1338
00:39:25,000 --> 00:39:25,480
a ver,

1339
00:39:25,480 --> 00:39:26,720
es que tenemos,

1340
00:39:26,720 --> 00:39:27,640
lo que voy a escribir es un

1341
00:39:27,640 --> 00:39:28,680
poco vamos a ahorrarnoslo,

1342
00:39:28,680 --> 00:39:29,240
porque es que,

1343
00:39:29,240 --> 00:39:30,480
si entendemos el método

1344
00:39:30,480 --> 00:39:32,080
checkUpdate desde el principio,

1345
00:39:32,080 --> 00:39:33,320
es más fácil.

1346
00:39:33,320 --> 00:39:35,600
Vámonos al método checkUpdate

1347
00:39:35,600 --> 00:39:37,640
este del almacén.

1348
00:39:37,640 --> 00:39:38,280
¿Dónde está?

1349
00:39:41,160 --> 00:39:41,680
AppStore,

1350
00:39:41,680 --> 00:39:43,120
aquí.

1351
00:39:43,120 --> 00:39:45,160
En el AppStore este teníamos

1352
00:39:45,160 --> 00:39:45,680
esto.

1353
00:39:48,200 --> 00:39:49,480
¿Vale?

1354
00:39:49,480 --> 00:39:50,120
Este método,

1355
00:39:50,120 --> 00:39:51,880
¿qué hacía?

1356
00:39:51,880 --> 00:39:53,840
Le dábamos una aplicación,

1357
00:39:53,840 --> 00:39:56,320
le dábamos una aplicación.

1358
00:39:56,320 --> 00:39:56,800
¿Vale?

1359
00:39:56,800 --> 00:40:00,280
Y te devolvía una copia de la

1360
00:40:00,280 --> 00:40:01,680
que hay en el almacén,

1361
00:40:01,680 --> 00:40:02,600
si la versión de la del

1362
00:40:02,600 --> 00:40:04,680
almacén es superior a esta.

1363
00:40:04,680 --> 00:40:05,080
Y si no,

1364
00:40:05,080 --> 00:40:06,880
te devuelve null.

1365
00:40:06,880 --> 00:40:07,360
Pero vamos a intentar

1366
00:40:07,360 --> 00:40:08,920
aprovecharnos de este método.

1367
00:40:08,920 --> 00:40:10,480
¿Cómo lo podríamos hacer?

1368
00:40:10,480 --> 00:40:11,960
Pues vamos a recorrer,

1369
00:40:11,960 --> 00:40:12,760
como ya sabemos que está

1370
00:40:12,760 --> 00:40:13,160
instalada,

1371
00:40:13,160 --> 00:40:15,360
vamos a recorrer las que tenemos

1372
00:40:15,360 --> 00:40:17,200
instaladas hasta que encontremos

1373
00:40:17,200 --> 00:40:19,440
la que está instalada.

1374
00:40:19,440 --> 00:40:21,280
Y ahora ya aprovechémonos de este

1375
00:40:21,280 --> 00:40:21,720
método,

1376
00:40:21,720 --> 00:40:23,840
vamos a pasársela.

1377
00:40:23,840 --> 00:40:25,720
Y este método ya nos devolverá

1378
00:40:25,720 --> 00:40:27,040
una copia de la actualizada,

1379
00:40:27,040 --> 00:40:29,600
pues esa copia que sustituya a la

1380
00:40:29,600 --> 00:40:32,840
de las instaladas.

1381
00:40:32,840 --> 00:40:34,080
Vamos a intentar plasmar esta

1382
00:40:34,080 --> 00:40:34,600
idea.

1383
00:40:34,600 --> 00:40:35,100
A ver.

1384
00:40:35,100 --> 00:40:35,600
A ver.

1385
00:40:40,700 --> 00:40:41,500
Estoy aquí.

1386
00:40:45,620 --> 00:40:47,860
Este prueba móvil no lo queremos.

1387
00:40:47,860 --> 00:40:48,340
Vale.

1388
00:40:48,340 --> 00:40:50,380
Pues vamos a recorrer la raya

1389
00:40:50,380 --> 00:40:51,260
hasta que encontremos la

1390
00:40:51,260 --> 00:40:52,340
instalada.

1391
00:40:52,340 --> 00:40:53,340
¿Vale?

1392
00:40:53,340 --> 00:40:54,220
Vamos a recorrerlo.

1393
00:41:06,100 --> 00:41:06,580
Vale.

1394
00:41:06,580 --> 00:41:07,340
Vamos a recorrerlo.

1395
00:41:12,380 --> 00:41:13,620
Dime.

1396
00:41:13,620 --> 00:41:14,140
Dime, dime.

1397
00:41:19,700 --> 00:41:21,020
Sí, luego podemos compactarlo,

1398
00:41:21,020 --> 00:41:21,900
pero vamos por parámetros

1399
00:41:21,900 --> 00:41:24,140
estructurados, ¿vale?

1400
00:41:24,140 --> 00:41:25,220
Vamos pensando por partes.

1401
00:41:31,500 --> 00:41:32,980
Y luego ya, pues lo que decimos.

1402
00:41:32,980 --> 00:41:34,380
Uno ya lo mira, decide,

1403
00:41:34,460 --> 00:41:35,820
pero lo que quiero es que tengamos

1404
00:41:35,820 --> 00:41:36,780
la cabeza estructurada.

1405
00:41:39,140 --> 00:41:43,380
Si instaladas de i.nombre

1406
00:41:46,380 --> 00:41:49,740
resulta que es igual al nombre de

1407
00:41:49,740 --> 00:41:51,380
la aplicación,

1408
00:41:51,380 --> 00:41:53,700
pues esta es la que yo tengo que

1409
00:41:53,700 --> 00:41:56,140
o dejar igual o sobreescribir,

1410
00:41:56,140 --> 00:41:59,340
o dejar igual o sobreescribir.

1411
00:41:59,340 --> 00:41:59,840
¿Vale?

1412
00:41:59,840 --> 00:42:00,820
Pues entonces,

1413
00:42:00,820 --> 00:42:01,900
¿qué tenía el método,

1414
00:42:01,900 --> 00:42:02,900
qué hacía este método?

1415
00:42:06,220 --> 00:42:07,300
Ahora en un ratín paramos.

1416
00:42:12,220 --> 00:42:14,340
¿Qué hacía este método de aquí?

1417
00:42:14,340 --> 00:42:15,220
CheckUpdate.

1418
00:42:15,220 --> 00:42:18,300
Si lo miramos, lo que hacía era,

1419
00:42:18,300 --> 00:42:19,860
cogía esta aplicación que yo le

1420
00:42:19,860 --> 00:42:22,980
daba, cogía una aplicación,

1421
00:42:22,980 --> 00:42:25,220
miraba a ver si su versión era

1422
00:42:25,220 --> 00:42:27,500
inferior a la versión de la que

1423
00:42:27,500 --> 00:42:28,660
hay en el almacén con el mismo

1424
00:42:28,660 --> 00:42:29,780
nombre.

1425
00:42:29,780 --> 00:42:30,580
Y si lo era,

1426
00:42:30,580 --> 00:42:33,780
me devolvía una copia de la del

1427
00:42:33,780 --> 00:42:35,860
almacén, de la actualizada.

1428
00:42:35,860 --> 00:42:37,540
Pues esa copia es justo la que

1429
00:42:37,540 --> 00:42:39,060
querríamos guardar en instaladas

1430
00:42:39,060 --> 00:42:41,380
de i, justo.

1431
00:42:41,380 --> 00:42:42,580
Entonces ya parece que nos vamos

1432
00:42:42,580 --> 00:42:43,860
acercando, ¿no?

1433
00:42:43,860 --> 00:42:44,780
Es decir, este método.

1434
00:42:44,780 --> 00:42:46,580
Recibe una aplicación.

1435
00:42:46,580 --> 00:42:49,980
Yo le paso la aplicación que he

1436
00:42:49,980 --> 00:42:53,180
encontrado que se llama igual.

1437
00:42:53,180 --> 00:42:54,980
Compruebo si su versión es menor

1438
00:42:54,980 --> 00:42:56,580
que la del almacén.

1439
00:42:56,580 --> 00:42:57,860
Y si es menor,

1440
00:42:57,860 --> 00:43:00,220
en esta posición quiero escribir

1441
00:43:00,220 --> 00:43:00,900
la actualizada,

1442
00:43:00,900 --> 00:43:02,140
que es justo la que me devuelve

1443
00:43:02,140 --> 00:43:03,060
este.

1444
00:43:03,060 --> 00:43:04,460
Luego podría hacer esto, ¿verdad?

1445
00:43:15,300 --> 00:43:16,620
¿También podrías utilizar algo

1446
00:43:16,620 --> 00:43:17,820
que te doy a cambiar la versión,

1447
00:43:17,820 --> 00:43:19,300
no?

1448
00:43:19,300 --> 00:43:20,300
¿Tú lo haces?

1449
00:43:20,300 --> 00:43:21,620
Primero lo chequeas y luego

1450
00:43:21,620 --> 00:43:22,820
utilizas el método de cambiar la

1451
00:43:22,820 --> 00:43:23,340
versión.

1452
00:43:23,340 --> 00:43:24,100
Sí, sí, sí.

1453
00:43:24,100 --> 00:43:25,180
Lo que pasa es que, a ver,

1454
00:43:25,180 --> 00:43:26,980
se supone que no,

1455
00:43:26,980 --> 00:43:28,580
que aquí es que solamente hay

1456
00:43:28,580 --> 00:43:29,260
tres propiedades.

1457
00:43:29,300 --> 00:43:30,220
Pero la idea es que tú tratas

1458
00:43:30,220 --> 00:43:31,460
de emular que se ha cambiado la

1459
00:43:31,460 --> 00:43:32,540
versión.

1460
00:43:32,540 --> 00:43:34,020
Hay más cosas que son nuevas.

1461
00:43:34,020 --> 00:43:34,940
Entonces, quieres el objeto

1462
00:43:34,940 --> 00:43:36,060
enterito.

1463
00:43:36,060 --> 00:43:37,660
No solo cambiar el campo versión

1464
00:43:37,660 --> 00:43:40,100
de la que está instalada ya.

1465
00:43:40,100 --> 00:43:40,300
¿Vale?

1466
00:43:40,300 --> 00:43:41,900
Quieres sobreescribirla con la

1467
00:43:41,900 --> 00:43:43,820
aplicación enterita del almacén.

1468
00:43:43,820 --> 00:43:44,860
Yo quiero sobreescribirla con el

1469
00:43:44,860 --> 00:43:45,700
objeto entero.

1470
00:43:45,700 --> 00:43:46,540
No solo quiero cambiar la

1471
00:43:46,540 --> 00:43:48,140
versión, ¿vale?

1472
00:43:48,140 --> 00:43:49,260
Entonces, por eso,

1473
00:43:49,260 --> 00:43:51,300
me creo una copia de la que está

1474
00:43:51,300 --> 00:43:52,500
en el almacén que tiene una

1475
00:43:52,500 --> 00:43:54,100
versión más actualizada que esta.

1476
00:43:54,100 --> 00:43:56,420
Y esa copia la sobreescribo.

1477
00:43:56,420 --> 00:43:57,660
Esa sería la idea, ¿verdad?

1478
00:43:57,660 --> 00:43:59,580
Para eso servía este método.

1479
00:43:59,580 --> 00:44:00,460
Una vez que la he encontrado,

1480
00:44:00,460 --> 00:44:01,060
sobreescribo.

1481
00:44:04,300 --> 00:44:05,300
Pero aquí solo hay un problema,

1482
00:44:05,300 --> 00:44:08,100
¿verdad?

1483
00:44:08,100 --> 00:44:09,100
Cuidado con este método,

1484
00:44:09,100 --> 00:44:10,300
que este método dice, oye,

1485
00:44:10,300 --> 00:44:12,300
si es igual te devuelvo un null.

1486
00:44:12,300 --> 00:44:13,500
Entonces, cuidado.

1487
00:44:13,500 --> 00:44:16,060
Porque si no hay que actualizar,

1488
00:44:16,060 --> 00:44:17,500
este me está devolviendo un null.

1489
00:44:17,500 --> 00:44:19,620
Entonces, si la versión de esta

1490
00:44:19,620 --> 00:44:21,500
es igual que la de esta,

1491
00:44:21,500 --> 00:44:22,980
el método funcionaba devolviendo

1492
00:44:22,980 --> 00:44:24,140
null.

1493
00:44:24,140 --> 00:44:24,940
Entonces, ojo,

1494
00:44:24,940 --> 00:44:27,180
esto solo hay que hacerlo si

1495
00:44:27,180 --> 00:44:28,740
esto es diferente de null.

1496
00:44:28,740 --> 00:44:30,100
Ojo, porque si es null es que la

1497
00:44:30,100 --> 00:44:30,980
versión es igual y no hay que

1498
00:44:30,980 --> 00:44:33,340
hacer nada, ¿vale?

1499
00:44:33,340 --> 00:44:34,780
Eso es lo que nos falta.

1500
00:44:34,780 --> 00:44:35,940
Ya he sepulido.

1501
00:44:35,940 --> 00:44:36,940
Cuidado.

1502
00:44:36,940 --> 00:44:42,340
Si o bien lo ponemos así o bien

1503
00:44:42,340 --> 00:44:45,940
lo hacemos para ir recordándonos

1504
00:44:45,940 --> 00:44:48,660
cosas instaladas de ahí, ¿qué hago?

1505
00:44:48,660 --> 00:44:49,660
Me hago la pregunta.

1506
00:44:49,660 --> 00:44:50,940
Cuidado.

1507
00:44:50,940 --> 00:45:00,020
¿Esto es igual a null?

1508
00:45:00,020 --> 00:45:00,900
¿Verdad?

1509
00:45:00,900 --> 00:45:03,460
Esta era la pregunta.

1510
00:45:03,460 --> 00:45:05,940
Entonces, si es igual a null,

1511
00:45:05,940 --> 00:45:07,100
entonces a instaladas de ahí no

1512
00:45:07,100 --> 00:45:08,180
le quiero cambiar el nombre.

1513
00:45:08,180 --> 00:45:09,580
Quiero que siga siendo instaladas

1514
00:45:09,580 --> 00:45:09,940
de ahí.

1515
00:45:09,940 --> 00:45:12,340
Ojo, no le cambio el nombre.

1516
00:45:12,340 --> 00:45:13,980
Y si no es igual,

1517
00:45:13,980 --> 00:45:15,380
entonces sí que quiero esto.

1518
00:45:21,420 --> 00:45:24,340
Ala, así lo complicamos un poco

1519
00:45:24,340 --> 00:45:25,980
para no olvidarnos de los

1520
00:45:25,980 --> 00:45:26,660
operadores.

1521
00:45:29,500 --> 00:45:30,940
Y ya está.

1522
00:45:30,940 --> 00:45:32,780
Busco en el array la aplicación

1523
00:45:32,780 --> 00:45:33,700
cuyo nombre es el que me han

1524
00:45:33,700 --> 00:45:35,340
pasado.

1525
00:45:35,340 --> 00:45:35,940
Cuidado.

1526
00:45:40,460 --> 00:45:42,340
¿La versión es la misma?

1527
00:45:42,340 --> 00:45:43,620
Que eso es lo que significa igual

1528
00:45:43,620 --> 00:45:43,860
a null.

1529
00:45:43,860 --> 00:45:45,260
¿La versión es la misma?

1530
00:45:45,260 --> 00:45:46,940
Entonces, no la toco.

1531
00:45:46,940 --> 00:45:48,300
¿La versión es distinta?

1532
00:45:48,300 --> 00:45:50,140
Entonces, la actualizo con la

1533
00:45:50,140 --> 00:45:52,140
nueva copia.

1534
00:45:52,140 --> 00:45:52,900
Y ya estaría.

1535
00:46:09,540 --> 00:46:09,900
Entonces, claro,

1536
00:46:09,900 --> 00:46:12,500
aquí lo raro es usar ese método

1537
00:46:12,500 --> 00:46:13,700
checkUpdate que está en la otra

1538
00:46:13,700 --> 00:46:14,100
clase.

1539
00:46:14,100 --> 00:46:15,660
Usarlo y entender que ese método,

1540
00:46:15,660 --> 00:46:17,780
pues, le pasabas una aplicación,

1541
00:46:17,780 --> 00:46:19,100
un almacén,

1542
00:46:19,100 --> 00:46:20,460
te buscaba en el almacén la

1543
00:46:20,460 --> 00:46:22,300
aplicación que se llamaba igual.

1544
00:46:22,300 --> 00:46:23,540
Si la versión era igual,

1545
00:46:23,540 --> 00:46:24,860
no te devolvía null.

1546
00:46:24,860 --> 00:46:25,980
Y si la versión era superior,

1547
00:46:25,980 --> 00:46:27,220
te devolvía copia de la del

1548
00:46:27,220 --> 00:46:28,220
almacén.

1549
00:46:28,220 --> 00:46:30,180
Bueno, pues, usando ese método,

1550
00:46:30,180 --> 00:46:32,820
podemos sobreescribir la

1551
00:46:32,820 --> 00:46:34,580
instalada con una copia de la

1552
00:46:34,580 --> 00:46:35,500
versión actualizada.

1553
00:46:41,700 --> 00:46:42,460
Y en principio,

1554
00:46:42,460 --> 00:46:43,340
a falta de errores,

1555
00:46:43,340 --> 00:46:44,500
que salga en la fase de pruebas

1556
00:46:44,500 --> 00:46:46,540
y eso estaría.

1557
00:46:46,540 --> 00:46:47,900
Y ahora es cuando uno ya mira el

1558
00:46:47,900 --> 00:46:49,260
método y dice, oye, a ver,

1559
00:46:49,260 --> 00:46:50,100
esto lo puedo arreglar,

1560
00:46:50,100 --> 00:46:51,100
lo puedo dejar un poco más

1561
00:46:51,100 --> 00:46:52,300
chulo, lo puedo dejar que el que

1562
00:46:52,300 --> 00:46:54,460
lo lea, pues, lo vea más claro.

1563
00:46:54,460 --> 00:46:55,180
Y sí, efectivamente,

1564
00:46:55,180 --> 00:46:56,020
hay muchas cosas que se pueden

1565
00:46:56,020 --> 00:46:56,780
hacer.

1566
00:46:56,780 --> 00:46:58,140
O sea, aquí estamos recorriendo

1567
00:46:58,140 --> 00:46:59,620
esto, efectivamente,

1568
00:46:59,620 --> 00:47:01,260
aquí abajo.

1569
00:47:01,260 --> 00:47:01,860
Y estamos haciendo el mismo

1570
00:47:01,860 --> 00:47:04,820
recorrido aquí arriba.

1571
00:47:04,820 --> 00:47:06,700
Entonces, podemos aprovechar,

1572
00:47:06,700 --> 00:47:07,740
una vez que ya lo tenemos hecho,

1573
00:47:07,740 --> 00:47:08,660
tenemos entendido,

1574
00:47:08,660 --> 00:47:11,060
tenemos, pues,

1575
00:47:11,060 --> 00:47:12,100
podemos aprovechar y decir,

1576
00:47:12,100 --> 00:47:12,580
hombre, a ver,

1577
00:47:12,580 --> 00:47:14,620
lo estoy recorriendo dos veces.

1578
00:47:14,620 --> 00:47:15,580
Pues, voy a aprovechar el

1579
00:47:15,580 --> 00:47:16,500
recorrido de arriba,

1580
00:47:16,500 --> 00:47:17,700
que es solo para saber si

1581
00:47:17,700 --> 00:47:18,820
está o no está,

1582
00:47:18,820 --> 00:47:19,700
para en el caso de que esté,

1583
00:47:19,700 --> 00:47:21,180
actualizarla.

1584
00:47:21,180 --> 00:47:23,580
Podríamos hacer eso, ¿no?

1585
00:47:23,580 --> 00:47:25,140
Entonces, este recorrido era

1586
00:47:25,140 --> 00:47:28,140
solo para ver si está o no está,

1587
00:47:28,140 --> 00:47:29,060
¿vale?

1588
00:47:29,060 --> 00:47:31,540
Pues, vamos a aprovechar y además

1589
00:47:31,540 --> 00:47:34,020
de usarlo para avisar de que

1590
00:47:34,020 --> 00:47:37,740
está, vamos ya de paso a

1591
00:47:37,740 --> 00:47:39,620
actualizarla, ¿verdad?

1592
00:47:39,620 --> 00:47:42,220
Vamos ya de paso a actualizarla.

1593
00:47:42,220 --> 00:47:43,140
Podemos aprovechar.

1594
00:47:43,140 --> 00:47:44,500
Ahora ya, esto ya se trata de,

1595
00:47:44,500 --> 00:47:45,940
uno echa un vistazo al código y

1596
00:47:45,940 --> 00:47:47,540
ya dice, ya tengo claro lo que

1597
00:47:47,540 --> 00:47:49,540
he hecho, ya tengo claro de que

1598
00:47:49,540 --> 00:47:50,940
va esto y, bueno, voy a verlo.

1599
00:47:50,940 --> 00:47:52,460
¿Puedo dejar un poco así más?

1600
00:47:52,460 --> 00:47:53,540
Venga.

1601
00:47:53,540 --> 00:47:55,060
Entonces, como identificamos 2

1602
00:47:55,060 --> 00:47:57,100
recorridos sobre el mismo array,

1603
00:47:57,100 --> 00:47:58,540
2 recorridos.

1604
00:47:58,540 --> 00:48:00,780
En lugar de hacer 2 recorridos,

1605
00:48:00,780 --> 00:48:02,060
uno que haga esto y otro que

1606
00:48:02,060 --> 00:48:04,060
haga esto, ¿puedo yo en un solo

1607
00:48:04,060 --> 00:48:06,860
recorrido hacer las 2 cosas?

1608
00:48:06,860 --> 00:48:08,140
A veces podría, a veces no.

1609
00:48:08,140 --> 00:48:09,020
Depende de lo que haya pasado

1610
00:48:09,020 --> 00:48:10,060
entre medias, claro.

1611
00:48:10,060 --> 00:48:13,740
En este caso, puedo.

1612
00:48:13,740 --> 00:48:14,460
Pues, nada.

1613
00:48:14,460 --> 00:48:16,300
Aprovecho este recorrido en el que

1614
00:48:16,300 --> 00:48:18,100
localizo la aplicación para

1615
00:48:18,100 --> 00:48:19,980
avisar de que está.

1616
00:48:19,980 --> 00:48:22,660
Y además de avisar de que está,

1617
00:48:22,660 --> 00:48:24,260
la actualizo de esta manera.

1618
00:48:31,220 --> 00:48:32,660
Porque me salía ahí un aviso del

1619
00:48:32,660 --> 00:48:33,500
rojo, pero bueno.

1620
00:48:37,420 --> 00:48:40,620
Ahora miramos a ver qué pasa.

1621
00:48:40,620 --> 00:48:42,300
Vale.

1622
00:48:42,300 --> 00:48:43,420
Bueno, pues, entonces, usamos

1623
00:48:43,540 --> 00:48:47,380
este for para, si está,

1624
00:48:47,380 --> 00:48:50,260
la actualizamos.

1625
00:48:50,260 --> 00:48:52,500
Y aparte avisamos.

1626
00:48:52,500 --> 00:48:55,980
Y ahora, si no está, entonces,

1627
00:48:55,980 --> 00:48:58,260
ahora ya, pues, hago esto que tenga

1628
00:48:58,260 --> 00:48:59,580
que hacer.

1629
00:48:59,580 --> 00:49:02,500
Y aquí yo creo que lo que me pasa

1630
00:49:02,500 --> 00:49:05,420
es que ahora tengo llaves raras

1631
00:49:05,420 --> 00:49:06,740
por ahí.

1632
00:49:06,740 --> 00:49:09,460
Entonces, vamos a revisar desde el

1633
00:49:09,460 --> 00:49:10,460
principio.

1634
00:49:10,460 --> 00:49:13,180
A ver, creo que tengo llaves

1635
00:49:13,220 --> 00:49:14,180
medio extrañas.

1636
00:49:14,180 --> 00:49:14,740
Vamos a ver.

1637
00:49:14,740 --> 00:49:17,700
Vamos a revisarlo.

1638
00:49:17,700 --> 00:49:20,020
Vale.

1639
00:49:20,020 --> 00:49:21,980
Recorro la RAI.

1640
00:49:21,980 --> 00:49:25,020
Si la encuentro,

1641
00:49:25,020 --> 00:49:27,180
la actualizo y aviso.

1642
00:49:27,180 --> 00:49:28,540
Y aquí cierro la llave de live.

1643
00:49:28,540 --> 00:49:30,140
Vale, que esta es la que me

1644
00:49:30,140 --> 00:49:31,500
falta.

1645
00:49:31,500 --> 00:49:32,060
Vale.

1646
00:49:32,060 --> 00:49:33,940
Cierro la llave de live.

1647
00:49:33,940 --> 00:49:35,500
Vale.

1648
00:49:35,500 --> 00:49:36,500
Y...

1649
00:49:44,140 --> 00:49:45,540
Ala, cerrada.

1650
00:49:45,540 --> 00:49:48,220
El for no tiene llave.

1651
00:49:48,220 --> 00:49:50,140
Y ahora que no estaba instalada,

1652
00:49:50,140 --> 00:49:51,180
hago todo el rollo que hemos

1653
00:49:51,180 --> 00:49:52,420
dicho.

1654
00:49:52,420 --> 00:49:54,380
Con lo cual, ahora ya este for me

1655
00:49:54,380 --> 00:49:56,100
sobra y ya puedo hacer cambios y

1656
00:49:56,100 --> 00:49:57,780
me queda todo más bonito.

1657
00:49:57,780 --> 00:49:59,380
Este for me sobra porque ya lo

1658
00:49:59,380 --> 00:50:01,020
he hecho arriba.

1659
00:50:01,020 --> 00:50:06,860
Al sobrarme este for,

1660
00:50:06,860 --> 00:50:08,740
este retún también me sobra.

1661
00:50:08,740 --> 00:50:10,020
También me sobra porque el método

1662
00:50:10,020 --> 00:50:10,900
acaba igualmente.

1663
00:50:10,900 --> 00:50:11,740
No hay nada debajo.

1664
00:50:11,740 --> 00:50:13,060
Con lo cual, ese retún también me

1665
00:50:13,060 --> 00:50:14,540
sobra.

1666
00:50:14,540 --> 00:50:17,220
Ese retún fuera.

1667
00:50:17,220 --> 00:50:17,980
Y no solo eso,

1668
00:50:17,980 --> 00:50:18,860
sino que me estoy empezando a

1669
00:50:18,860 --> 00:50:19,900
quitar un montón de cosas a

1670
00:50:19,900 --> 00:50:20,940
mogollón.

1671
00:50:20,940 --> 00:50:22,540
Es que ya hasta me sobra la

1672
00:50:22,540 --> 00:50:23,820
instalada.

1673
00:50:23,820 --> 00:50:24,620
Todo lo quito.

1674
00:50:24,620 --> 00:50:26,420
Pongo aquí un retún y esto lo

1675
00:50:26,420 --> 00:50:27,340
saco de live.

1676
00:50:27,340 --> 00:50:27,820
O sea,

1677
00:50:27,820 --> 00:50:28,740
es que al final se me está

1678
00:50:28,740 --> 00:50:30,060
quedando en nada.

1679
00:50:30,060 --> 00:50:31,020
Primero llevo una versión

1680
00:50:31,020 --> 00:50:31,860
estructurada en la que he

1681
00:50:31,860 --> 00:50:32,260
pensado,

1682
00:50:32,260 --> 00:50:33,780
pero tengo que hacer esto.

1683
00:50:33,780 --> 00:50:36,500
Y ahora ya no entendéis lo que

1684
00:50:36,500 --> 00:50:37,820
está pasando, ¿no?

1685
00:50:37,820 --> 00:50:38,220
Ahora ya,

1686
00:50:38,220 --> 00:50:39,940
cuando yo ya he hecho este for,

1687
00:50:39,940 --> 00:50:41,300
si la aplicación está instalada,

1688
00:50:41,300 --> 00:50:42,220
es que ya no tengo más que

1689
00:50:42,220 --> 00:50:42,540
hacer.

1690
00:50:42,540 --> 00:50:43,820
Es que ya he acabado porque ya

1691
00:50:43,820 --> 00:50:45,260
la he actualizado.

1692
00:50:45,260 --> 00:50:45,700
Con lo cual,

1693
00:50:45,700 --> 00:50:46,700
puedo hacer aquí un retún

1694
00:50:46,700 --> 00:50:49,540
estupendamente.

1695
00:50:49,540 --> 00:50:50,740
Porque si está instalada,

1696
00:50:50,740 --> 00:50:52,020
es que ya se acabó.

1697
00:50:52,020 --> 00:50:53,020
Ya no hay más que hacer.

1698
00:50:53,020 --> 00:50:54,740
Ya la he actualizado y el método

1699
00:50:54,740 --> 00:50:55,820
puede salir de ahí fuera

1700
00:50:55,820 --> 00:50:56,260
método.

1701
00:50:56,260 --> 00:50:57,340
Se acabó.

1702
00:50:57,340 --> 00:50:58,820
Entonces, si he hecho un retún,

1703
00:50:58,820 --> 00:51:00,620
este if ya no hace ninguna falta.

1704
00:51:00,620 --> 00:51:02,980
Porque si llega ahí es porque no

1705
00:51:02,980 --> 00:51:04,380
estaba instalada.

1706
00:51:04,380 --> 00:51:04,900
Entonces,

1707
00:51:04,900 --> 00:51:06,140
este if ya no hace ninguna falta

1708
00:51:06,140 --> 00:51:07,460
si yo hago un retún.

1709
00:51:07,460 --> 00:51:09,020
Y si ese if no hace ninguna falta,

1710
00:51:09,020 --> 00:51:10,180
tampoco hace falta la variable

1711
00:51:10,180 --> 00:51:11,140
instalada.

1712
00:51:11,140 --> 00:51:11,980
Entonces, fue la variable

1713
00:51:11,980 --> 00:51:12,740
instalada.

1714
00:51:12,740 --> 00:51:13,220
Entonces,

1715
00:51:13,220 --> 00:51:14,140
ahora ya sí que me queda un

1716
00:51:14,140 --> 00:51:17,020
código más cortito.

1717
00:51:17,020 --> 00:51:18,580
Pero, claro, de partida,

1718
00:51:18,580 --> 00:51:20,220
llegar al código más compacto,

1719
00:51:20,220 --> 00:51:21,700
pues, no tiene por qué ser fácil.

1720
00:51:27,420 --> 00:51:27,660
¿Vale?

1721
00:51:27,660 --> 00:51:30,340
Es que ya me quito todo esto.

1722
00:51:30,340 --> 00:51:33,820
Me quito esto.

1723
00:51:33,820 --> 00:51:36,500
Me quito esto.

1724
00:51:36,500 --> 00:51:39,500
Y me quito esta llave, ¿verdad?

1725
00:51:39,500 --> 00:51:42,580
Que da la del if.

1726
00:51:42,580 --> 00:51:43,940
Y se me ha quedado un método muy

1727
00:51:43,940 --> 00:51:45,060
corto.

1728
00:51:45,060 --> 00:51:47,020
Se me ha quedado este for para

1729
00:51:47,020 --> 00:51:47,900
ver si está instalada.

1730
00:51:47,900 --> 00:51:49,500
Si lo está, actualiza y fuera.

1731
00:51:49,500 --> 00:51:51,100
Se acabó método.

1732
00:51:51,100 --> 00:51:52,980
Que llegamos aquí.

1733
00:51:52,980 --> 00:51:53,740
Llegamos aquí.

1734
00:52:02,380 --> 00:52:05,780
Ay, esto era.

1735
00:52:05,780 --> 00:52:06,260
Vale.

1736
00:52:10,380 --> 00:52:13,540
Ay, no me lo formatea.

1737
00:52:13,540 --> 00:52:14,140
Porque está.

1738
00:52:14,140 --> 00:52:14,740
Vale.

1739
00:52:14,740 --> 00:52:15,540
Que llegamos aquí.

1740
00:52:15,540 --> 00:52:16,940
Esto, venga, pues,

1741
00:52:16,940 --> 00:52:17,820
los quito a mano.

1742
00:52:24,580 --> 00:52:26,460
Que llegamos a este punto.

1743
00:52:26,460 --> 00:52:27,460
Es porque no hemos salido por el

1744
00:52:27,460 --> 00:52:28,140
retún.

1745
00:52:28,140 --> 00:52:29,020
Luego, si no hemos salido por el

1746
00:52:29,020 --> 00:52:29,380
retún,

1747
00:52:29,380 --> 00:52:30,460
es porque no está instalada.

1748
00:52:30,460 --> 00:52:32,140
Pues, es cuando hago este rollo.

1749
00:52:32,140 --> 00:52:33,740
Y ya está.

1750
00:52:33,740 --> 00:52:35,020
Entonces, me he quitado ahí un

1751
00:52:35,020 --> 00:52:37,340
montón de historias.

1752
00:52:37,340 --> 00:52:39,340
Y la he dejado compactada en esta

1753
00:52:39,340 --> 00:52:41,140
parte para actualizar si es que

1754
00:52:41,140 --> 00:52:43,020
existe.

1755
00:52:43,020 --> 00:52:45,580
Y en esta para meter la nueva si

1756
00:52:45,580 --> 00:52:46,340
es que no existe.

1757
00:52:56,620 --> 00:52:59,420
Vale, pero siempre hacedos un

1758
00:52:59,420 --> 00:53:00,980
diagrama de flujo en la cabeza.

1759
00:53:00,980 --> 00:53:02,180
Siempre hacedos un flujo.

1760
00:53:02,180 --> 00:53:03,060
Tengo que hacer esto.

1761
00:53:03,060 --> 00:53:03,820
Ah, vale.

1762
00:53:03,820 --> 00:53:05,060
Voy a hacerme esta pregunta.

1763
00:53:05,060 --> 00:53:06,740
Ahora que no, pues, hago esto.

1764
00:53:06,740 --> 00:53:08,580
Siempre seguid un pensamiento

1765
00:53:08,620 --> 00:53:10,260
estructurado.

1766
00:53:10,260 --> 00:53:10,940
De ahí viene el nombre de

1767
00:53:10,940 --> 00:53:11,860
programación estructurada.

1768
00:53:11,860 --> 00:53:14,220
Porque tiene que estar perfectamente

1769
00:53:14,220 --> 00:53:15,060
claro el flujo.

1770
00:53:15,060 --> 00:53:16,700
Otra cosa es que luego,

1771
00:53:16,700 --> 00:53:17,740
una vez que uno ya tiene su

1772
00:53:17,740 --> 00:53:19,260
diagrama de flujo,

1773
00:53:19,260 --> 00:53:21,060
diga, ah, vale, mira, pues,

1774
00:53:21,060 --> 00:53:21,700
esto no sé qué,

1775
00:53:21,700 --> 00:53:22,460
esto no sé cuántos.

1776
00:53:28,020 --> 00:53:28,860
Bueno, pues,

1777
00:53:28,860 --> 00:53:30,140
este método a falta de que hagamos

1778
00:53:30,140 --> 00:53:34,860
las pruebas y se vaya al garete,

1779
00:53:34,860 --> 00:53:35,740
estaría tan bien.

1780
00:53:39,580 --> 00:53:40,140
¿Vale?

1781
00:53:43,900 --> 00:53:45,100
Vamos a parar un segundito y así

1782
00:53:45,100 --> 00:53:46,500
nos dejo grabada la respuesta.