Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 30-01-24 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 30 de enero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

que el teléfono se caracterizaba, su foto es la capacidad que tiene, 00:00:00
o sea no la capacidad que tiene libre en cada momento, 00:00:07
esa variable simplemente es la capacidad suya. 00:00:10
Entonces esa variable podríamos en realidad interpretarla como un valor constante, 00:00:14
en programación de toda la vida se mencionaba el concepto variables y constantes, 00:00:19
pues lo de constantes es un término que se ha ido fuera, 00:00:24
como lo del break es otro término que se ha ido fuera, 00:00:28
como lo de las variables globales, es otro término que se ha ido fuera, 00:00:33
porque son conceptos que dificultan de alguna manera las buenas prácticas de programación, 00:00:36
pues el concepto de constante de toda la vida que era, 00:00:43
era un valor, una variable que va a tener un valor fijo y que ese valor no va a cambiar nunca, 00:00:46
y es tan importante que no cambie nunca y que nadie lo cambie por error, 00:00:54
que yo lo declaro como constante, 00:00:58
entonces antes se declaraban de forma diferente las variables y las constantes, 00:01:01
eso ya de alguna manera se ha ido perdiendo, 00:01:05
pero aún así esa idea sigue existiendo, 00:01:10
la idea de que una aplicación tenga un valor para una variable 00:01:14
y que me interesa a mí que ese valor no cambie nunca, 00:01:17
pues entonces por ejemplo esta variable de aquí, 00:01:22
esta variable capacidad, es una variable que caracteriza al móvil 00:01:24
y es la capacidad máxima en gigas que tiene, 00:01:29
entonces podríamos interpretarla como que es un valor constante, 00:01:34
podríamos interpretarla, 00:01:38
hombre a menos si se le pone una ampliación de memoria o lo que sea podría tener más, 00:01:41
pero bueno vamos a imaginar que es un ejemplo de situación 00:01:45
en la cual una variable tiene un valor que yo quiero que no cambie, 00:01:49
eso es lo que sería el concepto de una constante, 00:01:52
lo que sería el concepto de una constante, 00:01:56
entonces en Java y en todos los lenguajes de programación 00:01:58
pues se incorpora algo para poder representar esa idea, 00:02:00
o sea el concepto de variable constante no existe en Java, 00:02:04
pero sí existen modificadores para hacer que una variable se comporte así, 00:02:08
como constante, 00:02:13
y es uno de los pocos modificadores que nos faltan por incorporar, 00:02:15
que es este modificador, 00:02:20
entonces este modificador significa el valor de esta variable, 00:02:29
una vez que lo reciba no se puede cambiar, 00:02:41
una vez que lo reciba no se puede cambiar, 00:02:45
eso significa el modificador final, 00:02:48
una variable que tiene el modificador final significa 00:02:51
una vez que la variable reciba este valor, 00:02:53
una vez que lo reciba ya no se puede cambiar, 00:02:56
entonces hace el papel de constante de toda la vida 00:03:01
y a veces es útil ponerlo así, 00:03:03
el modificador final se usa en más sitios, 00:03:05
o sea el modificador final se puede usar aquí también en clases, 00:03:08
se puede usar en métodos, 00:03:12
pero cuando se usa en clases o en métodos significa otra cosa, 00:03:14
y eso ya lo veremos cuando veamos herencia e implementación, 00:03:18
porque está relacionada con eso, 00:03:20
pero el modificador final en una variable significa, 00:03:22
esta variable una vez que reciba su valor, 00:03:26
ese valor ya no se puede tocar, 00:03:29
entonces es una idea que puede tener su interés reflejarla, 00:03:31
entonces aquí para incorporar ese modificador, 00:03:35
pues ya que estamos para incorporarlo, 00:03:37
vamos por ejemplo a ponerle aquí final a capacidad, 00:03:39
y así aseguramos que el que haga esta aplicación, 00:03:43
el que luego desarrolle para este teléfono, 00:03:46
no va a poderle cambiar la capacidad según le dé la gana, 00:03:48
no va a poder cambiarla, 00:03:50
lo que pasa es que el poner final significa, 00:03:52
que estás obligada a darle un valor, 00:03:55
estás obligada a darle un valor a esa variable, 00:03:58
entonces normalmente el sitio, hay matices para esto, 00:04:00
pero bueno el sitio de darle el valor a la variable, 00:04:03
es en el momento en el que la variable está final, 00:04:06
es en el momento en el que la declaras, 00:04:08
sería el momento de darle el valor, 00:04:11
o dárselo aquí en el constructor en el momento en el cual, 00:04:17
depende de U, depende de tu aplicación, 00:04:20
claro por lo que te digo, porque te obliga a inicializarla, 00:04:30
entonces al ponerle final significa, 00:04:35
esta variable es constante, 00:04:36
pero entonces no la dejes abierta, 00:04:38
no la dejes abierta, 00:04:41
entonces, bueno ya que he puesto 30, 00:04:42
eso haría que todos los móviles tienen capacidad 30, 00:04:44
hombre aquí lo natural sería a lo mejor, 00:04:48
ponerle cuando tú instancias el móvil, 00:04:51
pues decir voy a instanciar el móvil, 00:04:54
con una capacidad en concreto, 00:04:57
vale por ejemplo, 00:04:59
y ahora aquí me falta el, 00:05:01
por ejemplo, 00:05:16
vale entonces aquí tendríamos un constructor, 00:05:19
un constructor que te permite instanciar un teléfono, 00:05:21
con una capacidad máxima, 00:05:24
entonces voy a volver a ponerle sin parámetros, 00:05:26
porque me lo he ventilado y siempre un constructor, 00:05:28
sin parámetros, 00:05:30
interesa tenerlo, 00:05:33
porque puede ser que otros quieran usarlo, 00:05:34
ah bueno no, 00:05:37
no voy a poder, 00:05:38
si pongo el constructor sin parámetros, 00:05:39
me va a obligar a ponerlo aquí, 00:05:40
perdón, perdón, 00:05:42
he hecho una tontería, 00:05:43
he hecho una tontería, 00:05:43
vale, 00:05:44
bueno entonces, 00:05:45
la variable final significa eso, 00:05:46
la variable final significa, 00:05:49
claro, 00:05:51
la variable final significa, 00:05:51
oye esta variable cuando reciba valor, 00:05:53
no puede ser cambiado, 00:05:57
pero el poner final a una variable, 00:05:59
luego ya tiene implicaciones, 00:06:00
y es que te va a obligar a darle un valor inicial, 00:06:01
etcétera, 00:06:04
entonces tú eliges cómo dárselo, 00:06:04
en qué momento, 00:06:06
si a través del constructor, 00:06:06
bueno ya depende de tu aplicación, 00:06:08
vale, 00:06:10
entonces cuidado simplemente con que una variable sea final, 00:06:10
te obliga a darle un valor, 00:06:13
y ese valor ya no se va a quitar, 00:06:15
vale, 00:06:18
entonces aquí por ejemplo, 00:06:19
pues podemos optar por esto, 00:06:20
entonces los get y los set, 00:06:23
qué ocurre con las variables final, 00:06:25
pues que los get y los set, 00:06:27
dejan de tener sentido, 00:06:28
de hecho el set, 00:06:30
vale, 00:06:32
directamente se me ha puesto en rojo, 00:06:34
me dice, 00:06:36
oye cuidado que capacidad le acabas de hacer final, 00:06:36
eso de asignarle un valor, 00:06:40
no, 00:06:42
entonces los get y los set en las variables final, 00:06:43
dejan de tener sentido, 00:06:45
el set está claro, 00:06:46
porque hemos dicho que no podemos tocarla, 00:06:47
luego el set de la variable capacidad, 00:06:50
fuera, 00:06:53
lo voy a poner con un comentario, 00:06:55
para que quede claro, 00:06:57
porque lo hemos quitado, 00:06:59
capacidad es variable final, 00:07:03
con lo cual el set pierde el sentido, 00:07:08
vale, 00:07:17
o sea tienen un uso, 00:07:17
digamos que las variables final, 00:07:18
tienen un uso como muy concreto, 00:07:19
y Java se adapta a que las usemos así, 00:07:21
vale, 00:07:24
entonces lo voy a comentar, 00:07:24
vale, 00:07:31
desde el momento en que hemos decidido ponerla final, 00:07:32
este set tiene el sentido, 00:07:35
el get pierde el sentido, 00:07:37
hombre a ver no lo pierde, 00:07:38
el get está para que yo dado un móvil, 00:07:40
pueda ver la capacidad que tiene, 00:07:43
vale, 00:07:45
no hay ningún problema, 00:07:45
yo lo podría dejar así, 00:07:46
pero, 00:07:48
pero el uso habitual de las variables final, 00:07:49
suele ser otro, 00:07:53
vale, 00:07:54
suele ser otro, 00:07:55
lo normal es que las se pongan public, 00:07:56
y se acceda directamente, 00:08:00
a través del nombre de la clase, 00:08:02
suele ser la forma habitual de usarlas, 00:08:03
vale, 00:08:05
pero vamos a dejarlo ahora como está, 00:08:06
vamos a dejarlo ahora como está, 00:08:08
para no seguir tocando el resto de la aplicación, 00:08:10
lo único que quería incorporar, 00:08:14
de cara a esta aplicación, 00:08:15
lo único que quería incorporar era, 00:08:16
el concepto de modificador final en variables, 00:08:18
porque en métodos y clases significa otra cosa, 00:08:21
pues en variables significa, 00:08:27
esa variable, 00:08:29
una vez que reciba el valor, 00:08:30
no se puede tocar, 00:08:31
es una constante, 00:08:32
vale, 00:08:33
entonces, 00:08:36
si lo ponemos final, 00:08:37
va a tener luego implicaciones en nuestra aplicación, 00:08:38
y es que nos va a obligar a darle ese valor, 00:08:41
no se puede quedar indefinido, 00:08:43
etcétera, 00:08:44
simplemente eso, 00:08:45
vale, 00:08:45
simplemente eso, 00:08:46
bueno, 00:08:48
pues ya está, 00:08:49
vamos a poner, 00:08:49
capacidad a valor constante, 00:08:51
para que una vez que hemos creado el móvil, 00:08:53
con un tamaño de gigas, 00:08:55
nos aseguremos de que el resto de la aplicación no lo va a tocar, 00:08:58
vale, 00:09:01
a lo mejor puede ser que nos interesa que eso sea así, 00:09:01
bueno, 00:09:04
pues venga, 00:09:04
vamos a hacer como que nos interesa que eso sea así, 00:09:05
y así aprovechamos para incorporar ese modificador, 00:09:08
vale, 00:09:12
bueno, 00:09:13
pues ya está, 00:09:13
entonces, 00:09:14
nuestra clase móvil tenía, 00:09:14
su foto era, 00:09:16
la capacidad, 00:09:17
una vez que ha recibido la capacidad en el momento de ser creado, 00:09:18
esa no se toca, 00:09:22
el almacén de aplicaciones, 00:09:24
bueno hombre, 00:09:25
pues no le ponen, 00:09:25
puede ser variable, 00:09:27
y las instaladas, 00:09:28
ya está, 00:09:30
vale, 00:09:32
el modificador final, 00:09:32
hay que tener cuidado con él, 00:09:34
se usa, 00:09:35
solo, 00:09:37
si realmente aporta a la aplicación, 00:09:37
si le aporta, 00:09:40
porque es muy peligroso también, 00:09:40
es muy peligroso porque resta mucha libertad, 00:09:42
entonces de nuevo, 00:09:45
es lo de siempre, 00:09:46
cuidado con los diseños, 00:09:47
los diseños es que clases voy a usar, 00:09:49
qué variables me interesan cada clase, 00:09:52
qué tipo, 00:09:54
todo eso que son cuestiones de diseño, 00:09:55
cuidado con ellos porque son, 00:09:57
realmente lo más importante, 00:09:59
más que luego a la hora de hacer el método y hacer el código, 00:10:01
porque eso ya es hacer bucles, 00:10:04
for, 00:10:05
if, 00:10:06
cuidado con la parte de diseño, 00:10:07
hay muchas formas de hacer diseños distintos, 00:10:08
y algunas pues hacen aplicaciones más dificultosas que otras, 00:10:12
vale, 00:10:15
entonces cuidado, 00:10:15
con decidir alegremente que una variable sea final o no, 00:10:16
si aporta a la aplicación, 00:10:19
sí, 00:10:21
pero si no, 00:10:22
si no es imprescindible, 00:10:23
si no aporta, 00:10:25
no. 00:10:27
¿Y si resulta un fallo en el método? 00:10:28
Eh, 00:10:31
si habrán fallado, 00:10:31
con este cambio puede que hayan fallado más cosas, 00:10:32
si no lo sé, 00:10:34
tenemos que revisarlo, 00:10:34
vamos a ver, 00:10:37
eh, 00:10:38
vamos a revisar la clase, 00:10:39
por ahora teníamos, 00:10:40
las tres variables que caracterizan al teléfono, 00:10:41
y hemos puesto que una sea final, 00:10:43
vale, 00:10:46
los constructores, 00:10:47
uno que fija solamente la capacidad, 00:10:48
y luego a través de set, 00:10:49
los otras, 00:10:50
si ya no tendríamos constructor vacío, 00:10:52
eh, 00:10:55
es que, 00:10:56
si ponemos un constructor vacío, 00:10:57
claro, 00:11:00
te dice, 00:11:01
tendríamos que inicializar la capacidad aquí, 00:11:02
claro, 00:11:05
entonces ya inicializamos aquí, 00:11:05
el problema que tenemos es que, 00:11:07
cualquier teléfono, 00:11:08
que se instancie, 00:11:09
cualquier teléfono que se instancie va a tener la misma capacidad, 00:11:11
y no queremos eso, 00:11:13
entonces claro hay que adaptarse a la aplicación, 00:11:15
en este caso no podemos poner un constructor sin parámetros, 00:11:18
a menos que, 00:11:20
la inicialicemos ahí, 00:11:22
y no queremos hacer eso porque no se adapta, 00:11:23
vale, 00:11:25
normalmente es que, 00:11:26
el uso de las variables final suele ser, 00:11:28
cuando son constantes, 00:11:30
que son iguales, 00:11:32
para todos los objetos de una clase, 00:11:33
que son iguales para todos, 00:11:35
con lo cual además sería en static, 00:11:37
por eso a veces, 00:11:38
cuando veis final lo soléis ver asociado a static, 00:11:40
muchas veces, 00:11:43
porque es donde tiene más sentido, 00:11:44
donde tiene más sentido, 00:11:45
o sea mi aplicación tiene una constante, 00:11:47
que es un valor que yo quiero que sea ese, 00:11:49
el mismo para todos los objetos de la clase, 00:11:51
y además no cambiarlo, 00:11:54
pues la combinación de esas dos ideas es, 00:11:55
static, 00:11:57
porque es el mismo para todos, 00:11:58
y final, 00:11:59
la combinación de esas dos ideas, 00:11:59
vale, 00:12:01
que suele ser el uso habitual, 00:12:01
suele ser el uso habitual porque responde a muchas situaciones, 00:12:03
que uno quiere reflejar, 00:12:05
aquí es que es otra situación, 00:12:07
cada móvil tiene su propia capacidad, 00:12:10
pero distinta, 00:12:12
con lo cual esa variable no puede ser static, 00:12:13
porque cada móvil tiene la suya propia, 00:12:16
pero luego cada móvil, 00:12:18
la suya propia, 00:12:19
una vez creada no la puedo cambiar, 00:12:20
esta es otra situación distinta, 00:12:23
y en esta situación entonces, 00:12:25
yo si pongo un constructor sin parámetros, 00:12:27
vale, 00:12:32
pues entonces a ver, 00:12:32
podría poner un constructor sin parámetros, 00:12:32
y en el constructor inicializar capacidad, 00:12:35
pidiéndolo por teclado, 00:12:37
qué capacidad quiere para el teléfono, 00:12:38
por ejemplo, 00:12:40
pero me va a obligar a inicializar capacidad, 00:12:41
me va a obligar a inicializarlo, 00:12:44
ese es el problema, 00:12:45
que dejar uno sin parámetros y vacío, 00:12:47
no puedo, 00:12:49
la variable capacidad tiene que recibir un valor cuando el objeto se instancia, 00:12:50
ese es el asunto, 00:12:53
y yo ya programo y me adapto a eso, 00:12:54
en este caso, 00:12:56
pues bueno, 00:12:57
hago este constructor, 00:12:58
en el que la inicializo al valor que sea, 00:13:00
y ya está, 00:13:03
y dejo este otro, 00:13:05
vale, 00:13:08
pues seguimos repasando esta clase, 00:13:08
la foto de las tres cosas, 00:13:11
el get capacidad lo vamos a dejar ahí, 00:13:14
para recoger la capacidad cuando la queramos, 00:13:17
hemos modificado el set, 00:13:22
porque el set aquí ya deja de tener sentido, 00:13:23
el get y set de esto de aquí, 00:13:26
el get y set de las instaladas, 00:13:30
navegar por el app store, 00:13:32
y el status, 00:13:35
vale, 00:13:37
el status que te muestra los datos, 00:13:37
porque decías tú que el status, 00:13:39
o sea, 00:13:40
si el status es para mostrar solo, 00:13:41
entonces no, 00:13:42
claro, 00:13:49
pero porque tú lo que hacías, 00:13:49
te acuerdas que lo dijimos ayer, 00:13:50
tú hacías capacidad menos igual, 00:13:51
y te dije no, 00:13:54
no uses esa variable, 00:13:54
usa otra auxiliar, 00:13:55
porque la variable capacidad, 00:13:57
que es la que dice la capacidad del móvil, 00:13:58
no queremos tocarla, 00:14:00
queremos que el móvil tenga siempre la misma capacidad, 00:14:01
entonces claro, 00:14:05
a ti se te ha puesto en rojo cuando has intentado modificar esa variable, 00:14:05
pero claro, 00:14:09
yo no he intentado modificarla, 00:14:10
vale, 00:14:15
y ahora estábamos con este, 00:14:15
vale, 00:14:18
recibe un nombre, 00:14:19
la busca en el app store este, 00:14:20
bueno, 00:14:24
primero tendrá que mirar a ver si está instalada, 00:14:25
y si está instalada, 00:14:27
porque y si está instalada, 00:14:28
pues mira a ver si la del app store es una versión mayor para recuperar esa, 00:14:31
y si no está instalada, 00:14:34
la instala, 00:14:36
lo habéis hecho más o menos, 00:14:38
tú lo has hecho, 00:14:41
te ha quedado esa cosa larga, 00:14:42
pero bien, 00:14:43
o ya la has encogido, 00:14:45
a ver, 00:14:46
es que, 00:14:46
claro, 00:14:48
a ver, 00:14:48
si uno se pone a hacer esto así, 00:14:48
pa, 00:14:50
pa, 00:14:50
pa, 00:14:50
de seguido, 00:14:51
que es como estamos haciendo aquí las cosas, 00:14:52
o sea, 00:14:54
yo aquí estoy haciendo las cosas, 00:14:54
lo pongo esto en blanco directamente, 00:14:56
y me pongo a pensar en paralelo con vosotros sobre la marcha, 00:14:58
porque es el proceso que vosotros seguís, 00:15:02
y claro, 00:15:05
es normal, 00:15:05
de eso salen cosas raras, 00:15:06
pero luego sobre eso, 00:15:08
uno va iterando, 00:15:09
va viendo a ver si puede cambiar algo, 00:15:10
es el proceso de aprender, 00:15:11
y luego ya, 00:15:13
pues cuando pasa mucho tiempo, 00:15:13
pues a lo mejor a uno ya de partida, 00:15:15
le salen códigos más compactos de buenas a primeras, 00:15:17
pero si uno se pone a hacer esto de cero, 00:15:21
así lo normal es que le acabes, 00:15:22
al principio le sale una cosa muy rara, 00:15:24
¿vale? 00:15:26
Vale, 00:15:28
¿alguien más lo ha hecho aparte de él? 00:15:30
No es por regañar ni por poner nota, 00:15:31
es por, 00:15:33
vale, pues venga, 00:15:38
vamos a plantearnos entonces hacerlo, 00:15:39
a ver, 00:15:42
¿qué nos sale? 00:15:43
Venga, 00:15:44
apunto de lo que tenemos claro es que nos dan el nombre de una 00:15:45
aplicación, 00:15:47
entonces, 00:15:49
hay que tomar varias decisiones, 00:15:51
una, 00:15:53
¿está instalado o no lo está? 00:15:53
Si no lo está, 00:15:55
si no está instalada, 00:15:57
se trata de instalarla, 00:15:58
vale, 00:16:00
hasta ahí sencillo, 00:16:00
si no lo está es instalarla, 00:16:01
¿verdad? 00:16:02
A ver si entiendo bien el enunciado, 00:16:03
si no me lo decís, 00:16:04
y si está, 00:16:06
ahí se me pueden, 00:16:07
se me abren otras dos ramas, 00:16:08
la versión que está, 00:16:10
es igual, 00:16:12
tiene la misma versión que la de la péstora o menor, 00:16:12
porque si la tiene igual no hago nada, 00:16:16
y si la tiene menor, 00:16:18
la actualizo, 00:16:21
¿vale? 00:16:22
Entonces, 00:16:22
son una primera rama, 00:16:23
está o no está, 00:16:24
y en la rama de, 00:16:25
está, 00:16:27
a su vez tendré que hacerle otra pregunta, 00:16:28
podemos planteárnoslo así, 00:16:30
uno tiene que ver de alguna manera en la cabeza el flujo, 00:16:31
¿cuál va a ser el flujo de su código? 00:16:34
Pues el flujo ahora mismo sería, 00:16:36
vamos a hacernos la primera pregunta, 00:16:38
en función de lo que me dé alguna cosa o la otra, 00:16:41
y luego ya en cada rama, 00:16:44
si me tengo que hacer otra pregunta me la sigo haciendo. 00:16:46
Bueno, 00:16:49
pues entonces vamos a ver primero si está instalada, 00:16:49
ver si está instalada o no, 00:16:51
se tratará de recorrer las instaladas, 00:16:54
a ver si alguna de ellas, 00:16:57
su nombre es igual a este de aquí, 00:16:59
¿vale? 00:17:06
Pues venga, 00:17:07
vamos a hacerlo. 00:17:09
Primero, 00:17:12
comprobamos si ya está instalada, 00:17:14
¿vale? 00:17:19
Vamos haciéndonos las ramas, 00:17:19
el flujo, 00:17:20
le vamos haciendo las ramitas, 00:17:21
pues nada, 00:17:23
comprobar si ya está instalada, 00:17:24
pues por ejemplo, 00:17:25
podemos decir, 00:17:27
boolean instalada, 00:17:29
yo asumo que no, 00:17:30
y ahora voy a ver si lo está, 00:17:32
¿vale? 00:17:34
Porque esto de nuevo es, 00:17:35
voy a ver si algo pasa o no pasa, 00:17:36
voy a ver si está instalado o no lo está, 00:17:38
porque en función de si está o no está, 00:17:39
hago una cosa o hago otra, 00:17:42
vamos a intentar hacer un código, 00:17:44
un flujo, 00:17:46
un código organizado que responda a los patrones de pensamiento que hemos dicho, 00:17:47
y nos puede quedar algo largo, 00:17:52
pero bueno, 00:17:53
no pasa nada, 00:17:53
ya habrá tiempo, 00:17:54
si, 00:17:55
ah, 00:17:56
vale, 00:17:56
es que esto a lo mejor lo puedo reducir así, 00:17:56
pues ya lo reduciremos, 00:17:58
pero ahora mismo lo importante es que tengamos un pensamiento organizado, 00:18:00
y estructurado, 00:18:04
y que sepamos plasmarlo con los patrones que ya hemos visto, 00:18:05
¿no? 00:18:09
Entonces, 00:18:10
¿está instalada o no está instalada? 00:18:10
Vamos a verlo, 00:18:12
para ver si está instalada o no, 00:18:12
tengo que recorrer un array, 00:18:14
pues hacemos lo de siempre, 00:18:15
asumo que no está instalada, 00:18:16
y ahora me pongo a recorrer esto, 00:18:18
me pongo a recorrer mi array de instaladas, 00:18:20
que se llamaba instaladas, 00:18:24
que instaladas.len, 00:18:31
incrementando i, 00:18:33
vale, 00:18:36
pues vamos una por una, 00:18:37
si instaladas de i, 00:18:39
punto get nombre, 00:18:45
resulta que es igual, 00:18:48
que es igual, 00:18:51
que el nombre de la que me han dado que tengo que instalar, 00:18:52
pues ala, 00:18:57
instalada igual true, 00:18:58
no sé si está muy bien elegido los nombres de las variables, 00:19:03
pero se llama todo igual, 00:19:06
¿vale? 00:19:07
Entonces, 00:19:09
ya con esto puedo saber si está o no está, 00:19:10
¿vale? 00:19:14
Ahora de nuevo, 00:19:15
podría a lo mejor sacarme esto a un método auxiliar, 00:19:16
que me diga, 00:19:18
está instalada, 00:19:20
y llamar aquí al método, 00:19:21
si está instalada, 00:19:22
pues sí, 00:19:23
podríamos hacer eso, 00:19:23
sacarlo a un método auxiliar, 00:19:24
¿vale? 00:19:26
Pero, 00:19:26
vale, 00:19:28
entonces ahora ya le puedo hacer la pregunta, 00:19:28
ahora ya tengo una pregunta que hacerme, 00:19:30
ahora ya sí que puedo, 00:19:32
y es esta, 00:19:38
¿verdad? 00:19:39
Si está instalada o si no está instalada, 00:19:43
me la voy a hacer al revés, 00:19:48
para aprovecharme del retorno, 00:19:50
¿vale? 00:19:52
Entonces yo puedo hacer, 00:19:54
que no lo está, 00:19:55
que no lo está, 00:19:56
pues aquí que tengo que hacerla, 00:19:58
pasamos, 00:20:00
instalarla, 00:20:02
instalarla que será, 00:20:03
instalamos la aplicación, 00:20:05
instalar la aplicación que es, 00:20:08
pasar una copia, 00:20:10
una copia, 00:20:13
de la del App Store, 00:20:15
al, 00:20:21
a raíz de instaladas, 00:20:21
eso es instalarla, 00:20:25
¿no? 00:20:26
Eso es instalarla, 00:20:27
y una vez que lo hayamos hecho, 00:20:29
ya no tiene nada más que hacer el método, 00:20:31
¿verdad? 00:20:32
Si algo digo mal, 00:20:34
me lo decís, 00:20:36
yo estoy pensando sobre la marcha, 00:20:37
¿vale? 00:20:41
Entonces que no lo está, 00:20:42
la instalo y fuera, 00:20:44
y retorno. 00:20:46
Entonces como estoy en un método, 00:20:48
pues pongo el retorno y así me ahorro el ELSE, 00:20:51
¿verdad? 00:20:53
Si yo no pongo el retorno, 00:20:54
entonces tengo que poner aquí el ELSE, 00:20:56
y ya en la rama del ELSE hacerlo otro, 00:20:58
pero así es más cómodo, 00:21:00
¿verdad? 00:21:02
Así es más cómodo, 00:21:02
yo hago el retorno, 00:21:03
y ya está, 00:21:04
entonces si he llegado a este punto, 00:21:04
si he llegado a este punto, 00:21:06
es porque no entro aquí, 00:21:07
o lo que es lo mismo, 00:21:09
porque instalada es true, 00:21:10
entonces no hace falta que ponga el ELSE, 00:21:11
no lo hace falta, 00:21:13
¿vale? 00:21:15
Entonces eso es más cómodo. 00:21:17
Y ahora, 00:21:22
¿qué tendríamos que hacer después? 00:21:23
Que ya está instalada, 00:21:24
pues aquí ya lo que tendríamos que hacer es, 00:21:26
comprobar, 00:21:31
bueno, 00:21:33
hacernos la pregunta correspondiente, 00:21:33
¿versión de la instalada menor que la del app, 00:21:37
que la del store, 00:21:45
es menor? 00:21:48
Pues en ese caso sustituimos, 00:21:49
sustituimos la instalada por una copia de la del store, 00:21:53
que es más actual, 00:22:04
y ya está, 00:22:06
y saldríamos, 00:22:07
retorno, 00:22:08
¿vale? 00:22:09
Esto es lo que tendría que hacer el método. 00:22:09
Hemos hecho la primera rama, 00:22:11
¿está instalada o no lo está? 00:22:12
Para eso hemos hecho la estructura de arriba, 00:22:15
de toda la vida, 00:22:17
algo pasa o no pasa, 00:22:18
asumo de partida que no pasa, 00:22:20
y ahora ya recorro, 00:22:22
hago todas las comprobaciones que tenga que hacer, 00:22:23
a ver si alguna de ellas me hace cambiar de idea, 00:22:25
en cuanto una de ellas me haya hecho cambiar de idea, 00:22:28
cambia, 00:22:31
y cuando ese for ya ha terminado, 00:22:32
ya puedo pronunciarme sobre la decisión, 00:22:34
¿vale? 00:22:37
Bueno, pues ese ha sido mi primer if, 00:22:38
y ahora ya, 00:22:40
en el if de que no lo esté, 00:22:42
esto de aquí, 00:22:44
en el if de que sí que lo esté, 00:22:46
ahí se abre otra rama, 00:22:48
una otra pregunta y ya actúa en consecuencia, 00:22:49
¿vale? 00:22:52
Entonces intentemos siempre tener un pensamiento así, 00:22:53
estructurado, 00:22:55
adaptarme a lo que conocemos, 00:22:56
a lo que sabemos, 00:22:57
pues luego ya, 00:22:59
pues luego ya las cosas se pueden ir arreglando y dejando mejor, 00:23:00
¿vale? 00:23:02
Pues por ejemplo, 00:23:03
aquí que este for, 00:23:04
una vez que ha hecho true, 00:23:05
no siga, 00:23:07
pues poniendo ahí una condición, 00:23:08
o un break si me gustan los break, 00:23:09
o sacar esto a un método auxiliar, 00:23:11
que sea, 00:23:14
está instalada, 00:23:14
lo saco a un método auxiliar y lo llamo, 00:23:15
luego ya hay muchas cosas que se pueden hacer, 00:23:17
pero todo eso ya es, 00:23:20
darle a la manivela, 00:23:21
¿vale? 00:23:23
Una vez que uno ya tiene lo básico en la cabeza, 00:23:23
le puede dar a la manivela, 00:23:25
y hacer ya cualquier cosa, 00:23:26
cualquier cosa, 00:23:28
pero siempre teniendo un pensamiento, 00:23:29
de partida ya estructurado, 00:23:31
y bien puesto, 00:23:33
en la cabeza, 00:23:34
¿vale? 00:23:37
Venga, 00:23:38
pues entonces, 00:23:38
instalar la aplicación, 00:23:39
y va a implicar, 00:23:40
ahora ya vamos a pensar en esto, 00:23:41
¿qué tendríamos que hacer? 00:23:43
Bueno, 00:23:45
pues entonces tenemos que, 00:23:45
abrir este array, 00:23:49
una posición más, 00:23:51
una posición más, 00:23:53
abrirle una posición más, 00:23:54
y en esa posición, 00:23:56
llevar una copia, 00:23:58
de la del store, 00:24:00
que se llame así, 00:24:02
pero para eso, 00:24:04
teníamos un método en el store, 00:24:05
que es que ya te sacaba la copia directamente, 00:24:07
que se llamaba install, 00:24:09
¿verdad? 00:24:10
Si yo no recuerdo mal. 00:24:10
Install, 00:24:13
le pasabas el nombre de una aplicación, 00:24:14
y te devolvía una copia, 00:24:17
una copia del objeto aplicación del store, 00:24:20
con ese nombre. 00:24:22
Bueno, 00:24:24
entonces vamos a usar ese método install, 00:24:25
para generar la copia, 00:24:26
que vamos a llevar a la posición adicional, 00:24:28
simplemente, 00:24:31
¿vale? 00:24:32
Bueno, 00:24:33
pues entonces, 00:24:34
aquí, 00:24:36
¿qué tenemos que hacer entonces? 00:24:37
Hemos dicho, 00:24:39
como vamos a instalar una más, 00:24:40
es un rollo, 00:24:43
mientras sea un array, 00:24:43
es un rollo, 00:24:44
tenemos que a mano, 00:24:45
hacer una posición más, 00:24:46
a mano, 00:24:48
hay que hacerla a mano, 00:24:48
porque es un array, 00:24:49
no hay otra. 00:24:50
Bueno, 00:24:51
pues venga, 00:24:52
entonces vamos a hacerlo, 00:24:52
aquí, 00:24:57
¿vale? 00:25:00
Eso tiene que ser siempre, 00:25:01
como un array, 00:25:03
una vez que ya está declarado, 00:25:03
ese array sí o sí es inamovible, 00:25:05
a ese mismo no se le puede expandir, 00:25:07
eso es imposible, 00:25:10
pues eso siempre es de la misma manera, 00:25:11
me tendré que hacer otro, 00:25:13
con una posición más, 00:25:14
copio este en este, 00:25:16
y añado, 00:25:17
¿vale? 00:25:17
Porque lo que sí que es inamovible, 00:25:18
es que un array una vez hecho, 00:25:19
y declarado en memoria a su espacio, 00:25:20
a ese mismo, 00:25:22
no se le puede agrandar, 00:25:23
eso no se puede hacer, 00:25:24
hay que hacer otro, 00:25:26
y sustituir. 00:25:27
Venga, 00:25:30
pues vamos a hacer ese otro, 00:25:30
un array, 00:25:32
de aplicaciones auxiliares, 00:25:35
¿vale? 00:25:40
Que tenga, 00:25:41
el mismo tamaño, 00:25:44
que el de instaladas, 00:25:47
más uno, 00:25:48
ahora, 00:25:54
copiamos uno en el otro, 00:25:54
y ahora ya, 00:26:08
en aux.length, 00:26:09
no perdón, 00:26:11
instaladas.length, 00:26:13
aux de i, 00:26:17
igual a instaladas de i, 00:26:21
y ahora ya en la adicional, 00:26:26
una vez que ya hemos copiado, 00:26:28
la parte común, 00:26:30
en la adicional de aux, 00:26:30
y la adicional de aux, 00:26:33
es aux.length, 00:26:35
menos uno, 00:26:38
esta es su última posición, 00:26:39
la adicional, 00:26:41
pues en esta, 00:26:43
es donde hay que copiar, 00:26:44
una copia, 00:26:46
de la aplicación del store, 00:26:47
que se llame, 00:26:49
con el nombrecito que me han pasado, 00:26:50
pues es que ya tengo un método, 00:26:53
en el store que me hace eso, 00:26:55
ya tenemos un método en el store, 00:26:57
pues entonces, 00:26:59
que era instal, 00:27:01
pues ya está, 00:27:05
¿qué me hacía este método? 00:27:07
Que lo hemos programado antes, 00:27:08
se va al almacén, 00:27:09
que llama al método, 00:27:11
al almacén que llama al método, 00:27:12
en mi caso el almacén del teléfono, 00:27:13
la variable store, 00:27:15
que es el almacén del teléfono, 00:27:16
se va al almacén que llama al método, 00:27:18
busca, 00:27:20
la aplicación que se llama así, 00:27:21
y cuando la ha encontrado, 00:27:24
devuelve una copia, 00:27:25
de esa, 00:27:27
de esa aplicación, 00:27:29
devuelve una copia, 00:27:30
que es justo lo que queremos, 00:27:31
meter una copia ahí, 00:27:32
meter una copia ahí, 00:27:34
¿vale? 00:27:35
Y ahora ya, 00:27:40
pues lo único que tenemos que hacer, 00:27:41
es sustituir, 00:27:43
y que las aplicaciones instaladas, 00:27:44
del móvil, 00:27:46
ahora sean, 00:27:47
las de este array, 00:27:48
auxiliar que acabamos de construir, 00:27:50
las de este array auxiliar, 00:27:53
que acabamos de construir, 00:27:54
vale, 00:28:05
pues instalar la aplicación, 00:28:05
en principio ya está, 00:28:07
aquí ya podríamos, 00:28:09
esto tiene mucho sentido, 00:28:11
y parece así muy bonito, 00:28:12
y todo eso, 00:28:14
en realidad la única parte fea de esta, 00:28:14
es que hemos tenido que hacer este rollo, 00:28:16
porque es un array, 00:28:19
si en lugar de un array, 00:28:21
fuera otra estructura, 00:28:22
se quedaría en una línea, 00:28:23
pero es muy sencillo, 00:28:24
lo que hemos hecho, 00:28:26
lo que pasa es que, 00:28:28
bueno queda muy bonito, 00:28:28
tiene mucho sentido, 00:28:29
pero seguro que algunos, 00:28:30
ya podríais adivinar, 00:28:31
que esto no va a pasar, 00:28:32
la fase de pruebas, 00:28:33
¿verdad que no? 00:28:35
¿Por qué no va a pasar, 00:28:38
la fase de pruebas, 00:28:39
ya directamente en la primera prueba? 00:28:40
¿Qué va a pasar, 00:28:46
cuando tratemos de instalar, 00:28:47
la primera de las aplicaciones, 00:28:48
en el móvil, 00:28:50
la primera de todas, 00:28:52
yo acabo de arrancar mi móvil, 00:28:53
lo he construido, 00:28:54
voy a instalarle la primera, 00:28:55
si lo de siempre, 00:29:03
¿por qué? 00:29:04
¿Por qué? 00:29:09
Claro, 00:29:13
porque si es la primera, 00:29:14
que yo instalo, 00:29:15
acabo de arrancar mi teléfono, 00:29:16
que la RAI instaladas, 00:29:18
es nul todavía, 00:29:19
es nul todavía, 00:29:21
entonces si es la, 00:29:24
por eso siempre distinguimos, 00:29:25
oye, 00:29:26
es la primera que metes, 00:29:27
es la primera, 00:29:29
¿vale? 00:29:31
Entonces, 00:29:34
en lugar de, 00:29:34
como ahora ya, 00:29:35
lo manejamos todo, 00:29:36
tenemos un montón de cosas, 00:29:37
en la cabeza, 00:29:38
lo controlamos todo, 00:29:39
ya empezamos a estar más sueltos, 00:29:39
en lugar de arreglar ese error, 00:29:41
que ya prevemos, 00:29:43
¿verdad? 00:29:45
Lo que digo nos desconcierta, 00:29:46
¿no? 00:29:49
Pues, 00:29:50
en lugar de arreglar el error, 00:29:51
viene de aquí, ¿no? 00:29:52
Que el móvil, 00:29:53
cuando se, 00:29:54
yo inicialice por primera vez, 00:29:55
este ARRAI es nul. 00:29:58
Entonces, 00:30:01
eso va a ser nul, 00:30:01
y cuando yo llame a get up, 00:30:02
por primera vez, 00:30:04
cuando llame a get up, 00:30:06
por primera vez, 00:30:07
en cuanto salte a instaladas, 00:30:08
punto length, 00:30:10
ahí en el punto length, 00:30:11
es cuando va a decir, 00:30:12
nul point exception, 00:30:13
porque algo que es nul, 00:30:14
no puedes hacer punto lo que sea, 00:30:15
porque es nul. 00:30:16
Vale, pues, entonces, 00:30:18
eso como lo hemos arreglado otras 00:30:21
veces, 00:30:22
pues, hemos distinguido aquí, 00:30:23
hemos distinguido, 00:30:25
aquí, perdón, 00:30:27
hemos distinguido, 00:30:28
if instaladas igual a nul. 00:30:29
Entonces, 00:30:31
crea instaladas con un espacio y 00:30:31
lo haces, ¿vale? 00:30:33
Pero, 00:30:35
como ya sabemos, 00:30:36
lo entendemos todo de fondo, 00:30:38
vamos a arreglarlo de otra manera 00:30:39
distinta, 00:30:40
para variar. 00:30:41
Vamos a arreglarlo de otra manera 00:30:43
distinta. 00:30:43
Y es, oye, 00:30:46
pues, 00:30:49
cuando el móvil arranca, 00:30:49
le voy a dar yo ya un valor 00:30:51
inicial a esto, 00:30:52
le voy a dar yo ya un valor 00:30:54
inicial para que no sea nul, 00:30:55
para asegurarme de que no es nul 00:30:56
en el momento en que el móvil 00:30:58
arranque, 00:30:59
porque siempre se puede hacer eso, 00:31:02
¿no? 00:31:03
Las propiedades de una clase, 00:31:04
tú les das un valor inicial y eso 00:31:06
significa que cuando crees un 00:31:08
objeto de esa clase, 00:31:10
se creará espacio para las 00:31:12
propiedades, 00:31:13
se le dará el valor inicial y 00:31:14
luego ya se ejecutará el 00:31:16
constructor. 00:31:16
Vale. 00:31:19
Pues, 00:31:19
vamos a darle un valor inicial, 00:31:20
como es un array, 00:31:22
pues, 00:31:24
hay que darle algo de tipo 00:31:24
array, 00:31:26
no hay otra. 00:31:26
Y la pregunta sería, 00:31:28
uy, 00:31:29
ya, 00:31:29
pero cuántas posiciones le doy. 00:31:29
Yo quiero darle, 00:31:31
quiero que ese array inicialmente 00:31:32
no sea nul, 00:31:33
que se haya una dirección a algún 00:31:35
sitio, 00:31:36
pero cuántas posiciones le doy. 00:31:37
Pues, 00:31:40
es que no, 00:31:40
ahora mismo, 00:31:40
recién abierto el móvil, 00:31:41
es que no tiene ninguna instalada. 00:31:43
Pues, 00:31:44
no pasa nada, 00:31:44
le ponemos cero. 00:31:45
Esto se puede hacer. 00:31:46
Ya lo habéis hecho, 00:31:47
de hecho, 00:31:48
con Estefán alguna vez. 00:31:48
No pasa nada. 00:31:50
Esto se puede hacer, 00:31:51
se puede instanciar un array de 00:31:52
cero posiciones. 00:31:53
Y esto ya no es nul. 00:31:55
No es lo mismo nul, 00:31:57
que significa la dirección a la 00:31:58
nada, 00:32:00
o esto, 00:32:01
que significa apunto a una zona 00:32:01
para un array de cero posiciones. 00:32:05
No es lo mismo. 00:32:08
Esto ya no es nul. 00:32:09
¿Vale? 00:32:10
Entonces, 00:32:12
es otra forma de arreglarlo. 00:32:12
Entonces, 00:32:13
acostumbrémonos a todo. 00:32:14
Ahí, 00:32:15
con lo que lo entendamos, 00:32:15
todo. 00:32:16
Y los vamos a usar todo. 00:32:17
¿Vale? 00:32:18
Pues, 00:32:18
entonces, 00:32:19
cada vez que un móvil arranque, 00:32:19
se va a inicializar con un array 00:32:20
de instaladas de cero posiciones 00:32:22
todavía. 00:32:24
Pero ya no va a ser nul ese array. 00:32:24
Eso, 00:32:27
la implicación que tiene, 00:32:27
es que ya lo de aquí abajo ya sí 00:32:29
que va a funcionar. 00:32:31
Y no me va a dar un null pointer 00:32:32
exception. 00:32:34
Porque ahora ya, 00:32:35
el instaladas punto length, 00:32:40
me va a decir cero. 00:32:42
¿Vale? 00:32:44
Si el array está sin inicializar, 00:32:45
instaladas es null. 00:32:47
Luego, 00:32:48
null punto length es null pointer 00:32:49
excepción. 00:32:51
Pero si instaladas es new app cero, 00:32:52
no es null, 00:32:55
va a poder llamar. 00:32:56
¿Y qué va a devolver length? 00:32:57
Pues, 00:32:58
cero. 00:32:58
No pasa nada, 00:32:59
devuelve cero. 00:32:59
Y al devolver cero, 00:33:00
¿qué va a ocurrir? 00:33:01
Que nunca jamás va a entrar en 00:33:02
este array, 00:33:03
lógicamente, 00:33:03
pero es que no queremos que entre, 00:33:04
porque es que no va a estar 00:33:05
instalada. 00:33:06
Entonces, 00:33:07
va a devolver cero. 00:33:08
Y aquí también va a devolver cero. 00:33:09
Con lo cual, 00:33:11
al devolver cero, 00:33:12
el auxiliar se va a inicializar 00:33:13
con una posición, 00:33:15
que es justo lo que queremos, 00:33:17
con una. 00:33:18
¿Vale? 00:33:19
Entonces, 00:33:20
esa es una forma de arreglarlo 00:33:20
más cómoda. 00:33:23
¿Vale? 00:33:24
Siempre y cuando tenga yo la 00:33:25
opción de ir a la variable a 00:33:26
inicializarla. 00:33:29
Que puede haber situaciones en 00:33:31
las que no lo tenga. 00:33:32
Si no lo tengo, 00:33:33
tendremos que hacerlo como hemos 00:33:33
hecho hasta ahora, 00:33:34
distinguir y darle. 00:33:35
Pero si tengo yo la opción de 00:33:37
ir a la zona donde le he 00:33:38
declarado inicializarla, 00:33:39
inicializa cero y listo. 00:33:40
¿Vale? 00:33:44
Bueno, 00:33:45
pues, 00:33:45
entonces, 00:33:45
esto ya no nos va a dar null 00:33:45
pointer exception. 00:33:49
Esto nos va a dar cero. 00:33:50
Y esto nos va a dar cero cuando 00:33:52
sea la primera de todas, 00:33:54
claro. 00:33:55
Vale, pues, 00:33:56
ya está. 00:33:56
Que la aplicación no esté 00:33:57
instalada, 00:33:58
hemos acabado. 00:33:58
Retune, 00:33:59
fuera, 00:34:00
hemos acabado. 00:34:00
Y ahora, 00:34:01
¿qué pasa si está instalada? 00:34:02
Dime. 00:34:05
El retune sale del método. 00:34:12
El break asócialo a bucles. 00:34:15
O sea, 00:34:17
el break sale de bucles. 00:34:17
Sale de while, 00:34:19
sale de for. 00:34:20
¿Vale? 00:34:21
Pero el retune está asociado, 00:34:22
tiene que estar siempre dentro 00:34:23
de un método. 00:34:24
Entonces, 00:34:25
el retune sale del método. 00:34:25
Que además está dentro de un 00:34:27
for también saldría. 00:34:29
O sea, 00:34:30
es que directamente el retune 00:34:30
abandona el método y se va a la 00:34:31
siguiente línea desde la que se 00:34:34
llamó al método. 00:34:36
O sea, 00:34:37
abandona el método directamente. 00:34:37
El break simplemente sale del 00:34:39
bucle en el que esté. 00:34:41
Si está dentro de un for, 00:34:42
sale del for, 00:34:43
pero sigue por debajo del for. 00:34:43
O sea, 00:34:45
tú tienes un for con un break 00:34:45
dentro. 00:34:47
Tienes que tener el mismo cuidado 00:34:47
con poner una cosa y la otra. 00:34:48
Digo, 00:34:51
porque lo que puede ocurrir con 00:34:51
un break, 00:34:53
si lo pones en un bucle, 00:34:54
a lo mejor te interesa. 00:34:56
Bueno, 00:34:58
a ver, 00:34:58
o sea, 00:34:58
el problema del break, 00:34:59
o sea, 00:35:00
no es tanto lo que puede ocurrir, 00:35:00
sino la legibilidad. 00:35:02
El problema que lo haga más 00:35:03
ilegible, 00:35:04
porque uno está leyendo el código 00:35:05
y ve el break y dice, 00:35:06
oye, 00:35:08
¿y aquí por qué ha salido? 00:35:08
Entonces, 00:35:09
te tienes que ir, 00:35:10
tienes que entender todo el código 00:35:11
para ver por qué. 00:35:12
Entonces, 00:35:13
por eso, 00:35:13
es por lo que decimos que siempre 00:35:14
es mejor salir de los bucles 00:35:15
poniendo la condición arriba. 00:35:17
Porque el que está leyendo el 00:35:18
código, 00:35:19
al ver la condición expresada, 00:35:20
entiende en qué situaciones vas a 00:35:22
salir y en cuáles no. 00:35:24
El break no te dice, 00:35:25
es algo porque ha pasado esto, 00:35:26
te dice break. 00:35:28
Entonces, 00:35:29
lo de que sea desaconsejable es 00:35:29
por un tema de que lo hace más 00:35:31
ilegible. 00:35:33
Más. 00:35:34
¿Cuando el return primero cumple 00:35:34
la condición que tú lo pongas? 00:35:36
El return abandona el método en 00:35:38
el que estés. 00:35:40
O sea, 00:35:41
la diferencia entre cómo 00:35:41
funciona está clara, ¿no? 00:35:42
El break, o sea, 00:35:43
tú tienes un método con un for 00:35:44
dentro. 00:35:46
Digamos que no cumple el límite 00:35:48
de la condición. 00:35:50
Claro, o sea, 00:35:51
tú tienes, 00:35:51
yo tengo aquí un break. 00:35:52
Parte en cuanto encuentra lo que 00:35:52
tú has puesto en la condición. 00:35:54
¿Repite? 00:35:57
Sale en cuanto encuentra un 00:35:57
resultado. 00:36:00
El break, 00:36:00
dices. 00:36:01
Sí. 00:36:01
No, 00:36:02
el break sale en cuanto llegues 00:36:02
a él. 00:36:03
O sea, 00:36:03
de repente la máquina virtual 00:36:04
llega a un break. 00:36:05
Llega a un break, 00:36:06
yo tengo aquí un break, 00:36:06
por ejemplo, 00:36:07
pues, 00:36:07
entonces, 00:36:08
directamente el break no es que 00:36:08
mire condiciones y nada. 00:36:10
El break directamente sale del 00:36:11
bucle en el que esté. 00:36:13
Sale. 00:36:13
O sea, 00:36:15
el break significa sal del bucle. 00:36:15
Ni miras condiciones ni miras 00:36:17
nada, 00:36:18
pero solo de ese bucle, 00:36:18
pero solo de ese bucle. 00:36:19
Entonces, 00:36:21
la diferencia entre poner aquí un 00:36:22
break y un return, 00:36:23
imagínate que yo tengo aquí, 00:36:24
¿vale? 00:36:27
Tengo aquí un break. 00:36:28
El break, 00:36:34
está acá lo que haría. 00:36:34
Al llegar aquí, 00:36:35
el break sale del bucle en el 00:36:36
que estás. 00:36:38
¿En qué bucle estás? 00:36:39
En el for. 00:36:40
Sale. 00:36:41
Allá pasa lo que haya pasado, 00:36:42
ni mira condiciones ni mira 00:36:43
nada. 00:36:44
Cuando uno llega al break, 00:36:44
fuera, 00:36:46
se acabó el bucle. 00:36:46
Entonces, 00:36:47
continuarías por aquí. 00:36:47
Pero el programa sigue, 00:36:49
pero sigue por ahí. 00:36:51
¿Qué pasa si yo pongo un 00:36:52
return? 00:36:53
El return lo que hace es, 00:36:55
sales del método directamente. 00:36:57
Es que ya no haces nada más. 00:36:58
El método se acabó. 00:37:00
Sales. 00:37:02
El método terminado. 00:37:02
Entonces, 00:37:04
del break sales del bucle en el 00:37:04
que estás metido, 00:37:06
pero continúas por abajo. 00:37:06
Y el return significa, 00:37:08
ya no hay más que hacer. 00:37:09
El método se acabó. 00:37:10
Ya no hay más. 00:37:12
¿Vale? 00:37:13
Entonces, 00:37:15
sí que es cierto también que 00:37:15
puede, 00:37:17
que el return, 00:37:17
abusar de ellos, 00:37:19
pues, 00:37:20
puede hacer un poquito, 00:37:20
a lo mejor, 00:37:22
ilegible el código. 00:37:22
Porque si tú ves mucho return, 00:37:24
claro, 00:37:25
¿vale? 00:37:26
Pero es que con el return 00:37:27
también tienes mucho que ganar 00:37:28
porque, 00:37:30
a su vez, 00:37:31
te ahorras los saleses. 00:37:31
Entonces, 00:37:35
al ahorrarte los saleses, 00:37:35
a veces también te lo puede hacer 00:37:37
más legible. 00:37:38
Entonces, 00:37:39
el return, 00:37:39
pues, bueno, 00:37:40
es un poquito el equilibrio 00:37:40
dependiendo de. 00:37:41
Entonces, 00:37:46
en nuestro caso no queremos, 00:37:46
no ponemos ni return ni break por 00:37:48
ahora y ya está. 00:37:49
¿Vale? 00:37:53
Entonces, 00:37:53
si no está instalada, 00:37:54
la instalamos. 00:37:55
Y ahora, 00:37:55
estábamos aquí. 00:37:56
Sí está instalada. 00:37:58
Sí está. 00:37:59
Hemos llegado ahí. 00:37:59
Esto sería como si no pusiéramos 00:38:01
return, 00:38:03
aquí tendría que haber un ELSE. 00:38:03
Eso está claro, ¿no? 00:38:04
Si yo no pongo el return, 00:38:06
aquí tiene que haber un ELSE. 00:38:07
Entonces, 00:38:08
el poner el return me ahorra el 00:38:09
ELSE. 00:38:10
Es un tema de comodidad, 00:38:10
en realidad. 00:38:12
¿Vale? 00:38:13
Que he llegado ahí, 00:38:14
que he llegado aquí, 00:38:15
si he llegado aquí, 00:38:15
es porque la aplicación estaba 00:38:16
ya instalada. 00:38:18
Estaba. 00:38:19
Porque si no, 00:38:19
habría salido por ahí arriba. 00:38:20
¿Vale? 00:38:22
Pues, 00:38:22
si está, 00:38:22
¿qué es lo que tenemos que hacer? 00:38:22
Comprobar su versión. 00:38:24
¿Vale? 00:38:29
Entonces, 00:38:30
comprobar la versión de la 00:38:31
aplicación que se llame así, 00:38:33
dentro de las instaladas. 00:38:36
Entonces, 00:38:39
¿tenemos algún método hecho por 00:38:40
aquí que me devuelva la 00:38:42
aplicación que tengo yo 00:38:43
instaladas? 00:38:46
No, 00:38:46
no tenemos ninguno. 00:38:47
Entonces, 00:38:48
tendríamos que recorrer las 00:38:48
instaladas hasta que la 00:38:50
encontremos, 00:38:52
recorrer las instaladas hasta 00:38:56
que la encontremos, 00:38:57
a ver cuál es su versión. 00:38:58
Por ejemplo, 00:38:59
la int versión instalada. 00:39:00
¿Vale? 00:39:08
Y ahora podemos recorrer por 00:39:13
int y, 00:39:15
bueno, 00:39:24
a ver, 00:39:25
es que tenemos, 00:39:25
lo que voy a escribir es un 00:39:26
poco vamos a ahorrarnoslo, 00:39:27
porque es que, 00:39:28
si entendemos el método 00:39:29
checkUpdate desde el principio, 00:39:30
es más fácil. 00:39:32
Vámonos al método checkUpdate 00:39:33
este del almacén. 00:39:35
¿Dónde está? 00:39:37
AppStore, 00:39:41
aquí. 00:39:41
En el AppStore este teníamos 00:39:43
esto. 00:39:45
¿Vale? 00:39:48
Este método, 00:39:49
¿qué hacía? 00:39:50
Le dábamos una aplicación, 00:39:51
le dábamos una aplicación. 00:39:53
¿Vale? 00:39:56
Y te devolvía una copia de la 00:39:56
que hay en el almacén, 00:40:00
si la versión de la del 00:40:01
almacén es superior a esta. 00:40:02
Y si no, 00:40:04
te devuelve null. 00:40:05
Pero vamos a intentar 00:40:06
aprovecharnos de este método. 00:40:07
¿Cómo lo podríamos hacer? 00:40:08
Pues vamos a recorrer, 00:40:10
como ya sabemos que está 00:40:11
instalada, 00:40:12
vamos a recorrer las que tenemos 00:40:13
instaladas hasta que encontremos 00:40:15
la que está instalada. 00:40:17
Y ahora ya aprovechémonos de este 00:40:19
método, 00:40:21
vamos a pasársela. 00:40:21
Y este método ya nos devolverá 00:40:23
una copia de la actualizada, 00:40:25
pues esa copia que sustituya a la 00:40:27
de las instaladas. 00:40:29
Vamos a intentar plasmar esta 00:40:32
idea. 00:40:34
A ver. 00:40:34
A ver. 00:40:35
Estoy aquí. 00:40:40
Este prueba móvil no lo queremos. 00:40:45
Vale. 00:40:47
Pues vamos a recorrer la raya 00:40:48
hasta que encontremos la 00:40:50
instalada. 00:40:51
¿Vale? 00:40:52
Vamos a recorrerlo. 00:40:53
Vale. 00:41:06
Vamos a recorrerlo. 00:41:06
Dime. 00:41:12
Dime, dime. 00:41:13
Sí, luego podemos compactarlo, 00:41:19
pero vamos por parámetros 00:41:21
estructurados, ¿vale? 00:41:21
Vamos pensando por partes. 00:41:24
Y luego ya, pues lo que decimos. 00:41:31
Uno ya lo mira, decide, 00:41:32
pero lo que quiero es que tengamos 00:41:34
la cabeza estructurada. 00:41:35
Si instaladas de i.nombre 00:41:39
resulta que es igual al nombre de 00:41:46
la aplicación, 00:41:49
pues esta es la que yo tengo que 00:41:51
o dejar igual o sobreescribir, 00:41:53
o dejar igual o sobreescribir. 00:41:56
¿Vale? 00:41:59
Pues entonces, 00:41:59
¿qué tenía el método, 00:42:00
qué hacía este método? 00:42:01
Ahora en un ratín paramos. 00:42:06
¿Qué hacía este método de aquí? 00:42:12
CheckUpdate. 00:42:14
Si lo miramos, lo que hacía era, 00:42:15
cogía esta aplicación que yo le 00:42:18
daba, cogía una aplicación, 00:42:19
miraba a ver si su versión era 00:42:22
inferior a la versión de la que 00:42:25
hay en el almacén con el mismo 00:42:27
nombre. 00:42:28
Y si lo era, 00:42:29
me devolvía una copia de la del 00:42:30
almacén, de la actualizada. 00:42:33
Pues esa copia es justo la que 00:42:35
querríamos guardar en instaladas 00:42:37
de i, justo. 00:42:39
Entonces ya parece que nos vamos 00:42:41
acercando, ¿no? 00:42:42
Es decir, este método. 00:42:43
Recibe una aplicación. 00:42:44
Yo le paso la aplicación que he 00:42:46
encontrado que se llama igual. 00:42:49
Compruebo si su versión es menor 00:42:53
que la del almacén. 00:42:54
Y si es menor, 00:42:56
en esta posición quiero escribir 00:42:57
la actualizada, 00:43:00
que es justo la que me devuelve 00:43:00
este. 00:43:02
Luego podría hacer esto, ¿verdad? 00:43:03
¿También podrías utilizar algo 00:43:15
que te doy a cambiar la versión, 00:43:16
no? 00:43:17
¿Tú lo haces? 00:43:19
Primero lo chequeas y luego 00:43:20
utilizas el método de cambiar la 00:43:21
versión. 00:43:22
Sí, sí, sí. 00:43:23
Lo que pasa es que, a ver, 00:43:24
se supone que no, 00:43:25
que aquí es que solamente hay 00:43:26
tres propiedades. 00:43:28
Pero la idea es que tú tratas 00:43:29
de emular que se ha cambiado la 00:43:30
versión. 00:43:31
Hay más cosas que son nuevas. 00:43:32
Entonces, quieres el objeto 00:43:34
enterito. 00:43:34
No solo cambiar el campo versión 00:43:36
de la que está instalada ya. 00:43:37
¿Vale? 00:43:40
Quieres sobreescribirla con la 00:43:40
aplicación enterita del almacén. 00:43:41
Yo quiero sobreescribirla con el 00:43:43
objeto entero. 00:43:44
No solo quiero cambiar la 00:43:45
versión, ¿vale? 00:43:46
Entonces, por eso, 00:43:48
me creo una copia de la que está 00:43:49
en el almacén que tiene una 00:43:51
versión más actualizada que esta. 00:43:52
Y esa copia la sobreescribo. 00:43:54
Esa sería la idea, ¿verdad? 00:43:56
Para eso servía este método. 00:43:57
Una vez que la he encontrado, 00:43:59
sobreescribo. 00:44:00
Pero aquí solo hay un problema, 00:44:04
¿verdad? 00:44:05
Cuidado con este método, 00:44:08
que este método dice, oye, 00:44:09
si es igual te devuelvo un null. 00:44:10
Entonces, cuidado. 00:44:12
Porque si no hay que actualizar, 00:44:13
este me está devolviendo un null. 00:44:16
Entonces, si la versión de esta 00:44:17
es igual que la de esta, 00:44:19
el método funcionaba devolviendo 00:44:21
null. 00:44:22
Entonces, ojo, 00:44:24
esto solo hay que hacerlo si 00:44:24
esto es diferente de null. 00:44:27
Ojo, porque si es null es que la 00:44:28
versión es igual y no hay que 00:44:30
hacer nada, ¿vale? 00:44:30
Eso es lo que nos falta. 00:44:33
Ya he sepulido. 00:44:34
Cuidado. 00:44:35
Si o bien lo ponemos así o bien 00:44:36
lo hacemos para ir recordándonos 00:44:42
cosas instaladas de ahí, ¿qué hago? 00:44:45
Me hago la pregunta. 00:44:48
Cuidado. 00:44:49
¿Esto es igual a null? 00:44:50
¿Verdad? 00:45:00
Esta era la pregunta. 00:45:00
Entonces, si es igual a null, 00:45:03
entonces a instaladas de ahí no 00:45:05
le quiero cambiar el nombre. 00:45:07
Quiero que siga siendo instaladas 00:45:08
de ahí. 00:45:09
Ojo, no le cambio el nombre. 00:45:09
Y si no es igual, 00:45:12
entonces sí que quiero esto. 00:45:13
Ala, así lo complicamos un poco 00:45:21
para no olvidarnos de los 00:45:24
operadores. 00:45:25
Y ya está. 00:45:29
Busco en el array la aplicación 00:45:30
cuyo nombre es el que me han 00:45:32
pasado. 00:45:33
Cuidado. 00:45:35
¿La versión es la misma? 00:45:40
Que eso es lo que significa igual 00:45:42
a null. 00:45:43
¿La versión es la misma? 00:45:43
Entonces, no la toco. 00:45:45
¿La versión es distinta? 00:45:46
Entonces, la actualizo con la 00:45:48
nueva copia. 00:45:50
Y ya estaría. 00:45:52
Entonces, claro, 00:46:09
aquí lo raro es usar ese método 00:46:09
checkUpdate que está en la otra 00:46:12
clase. 00:46:13
Usarlo y entender que ese método, 00:46:14
pues, le pasabas una aplicación, 00:46:15
un almacén, 00:46:17
te buscaba en el almacén la 00:46:19
aplicación que se llamaba igual. 00:46:20
Si la versión era igual, 00:46:22
no te devolvía null. 00:46:23
Y si la versión era superior, 00:46:24
te devolvía copia de la del 00:46:25
almacén. 00:46:27
Bueno, pues, usando ese método, 00:46:28
podemos sobreescribir la 00:46:30
instalada con una copia de la 00:46:32
versión actualizada. 00:46:34
Y en principio, 00:46:41
a falta de errores, 00:46:42
que salga en la fase de pruebas 00:46:43
y eso estaría. 00:46:44
Y ahora es cuando uno ya mira el 00:46:46
método y dice, oye, a ver, 00:46:47
esto lo puedo arreglar, 00:46:49
lo puedo dejar un poco más 00:46:50
chulo, lo puedo dejar que el que 00:46:51
lo lea, pues, lo vea más claro. 00:46:52
Y sí, efectivamente, 00:46:54
hay muchas cosas que se pueden 00:46:55
hacer. 00:46:56
O sea, aquí estamos recorriendo 00:46:56
esto, efectivamente, 00:46:58
aquí abajo. 00:46:59
Y estamos haciendo el mismo 00:47:01
recorrido aquí arriba. 00:47:01
Entonces, podemos aprovechar, 00:47:04
una vez que ya lo tenemos hecho, 00:47:06
tenemos entendido, 00:47:07
tenemos, pues, 00:47:08
podemos aprovechar y decir, 00:47:11
hombre, a ver, 00:47:12
lo estoy recorriendo dos veces. 00:47:12
Pues, voy a aprovechar el 00:47:14
recorrido de arriba, 00:47:15
que es solo para saber si 00:47:16
está o no está, 00:47:17
para en el caso de que esté, 00:47:18
actualizarla. 00:47:19
Podríamos hacer eso, ¿no? 00:47:21
Entonces, este recorrido era 00:47:23
solo para ver si está o no está, 00:47:25
¿vale? 00:47:28
Pues, vamos a aprovechar y además 00:47:29
de usarlo para avisar de que 00:47:31
está, vamos ya de paso a 00:47:34
actualizarla, ¿verdad? 00:47:37
Vamos ya de paso a actualizarla. 00:47:39
Podemos aprovechar. 00:47:42
Ahora ya, esto ya se trata de, 00:47:43
uno echa un vistazo al código y 00:47:44
ya dice, ya tengo claro lo que 00:47:45
he hecho, ya tengo claro de que 00:47:47
va esto y, bueno, voy a verlo. 00:47:49
¿Puedo dejar un poco así más? 00:47:50
Venga. 00:47:52
Entonces, como identificamos 2 00:47:53
recorridos sobre el mismo array, 00:47:55
2 recorridos. 00:47:57
En lugar de hacer 2 recorridos, 00:47:58
uno que haga esto y otro que 00:48:00
haga esto, ¿puedo yo en un solo 00:48:02
recorrido hacer las 2 cosas? 00:48:04
A veces podría, a veces no. 00:48:06
Depende de lo que haya pasado 00:48:08
entre medias, claro. 00:48:09
En este caso, puedo. 00:48:10
Pues, nada. 00:48:13
Aprovecho este recorrido en el que 00:48:14
localizo la aplicación para 00:48:16
avisar de que está. 00:48:18
Y además de avisar de que está, 00:48:19
la actualizo de esta manera. 00:48:22
Porque me salía ahí un aviso del 00:48:31
rojo, pero bueno. 00:48:32
Ahora miramos a ver qué pasa. 00:48:37
Vale. 00:48:40
Bueno, pues, entonces, usamos 00:48:42
este for para, si está, 00:48:43
la actualizamos. 00:48:47
Y aparte avisamos. 00:48:50
Y ahora, si no está, entonces, 00:48:52
ahora ya, pues, hago esto que tenga 00:48:55
que hacer. 00:48:58
Y aquí yo creo que lo que me pasa 00:48:59
es que ahora tengo llaves raras 00:49:02
por ahí. 00:49:05
Entonces, vamos a revisar desde el 00:49:06
principio. 00:49:09
A ver, creo que tengo llaves 00:49:10
medio extrañas. 00:49:13
Vamos a ver. 00:49:14
Vamos a revisarlo. 00:49:14
Vale. 00:49:17
Recorro la RAI. 00:49:20
Si la encuentro, 00:49:21
la actualizo y aviso. 00:49:25
Y aquí cierro la llave de live. 00:49:27
Vale, que esta es la que me 00:49:28
falta. 00:49:30
Vale. 00:49:31
Cierro la llave de live. 00:49:32
Vale. 00:49:33
Y... 00:49:35
Ala, cerrada. 00:49:44
El for no tiene llave. 00:49:45
Y ahora que no estaba instalada, 00:49:48
hago todo el rollo que hemos 00:49:50
dicho. 00:49:51
Con lo cual, ahora ya este for me 00:49:52
sobra y ya puedo hacer cambios y 00:49:54
me queda todo más bonito. 00:49:56
Este for me sobra porque ya lo 00:49:57
he hecho arriba. 00:49:59
Al sobrarme este for, 00:50:01
este retún también me sobra. 00:50:06
También me sobra porque el método 00:50:08
acaba igualmente. 00:50:10
No hay nada debajo. 00:50:10
Con lo cual, ese retún también me 00:50:11
sobra. 00:50:13
Ese retún fuera. 00:50:14
Y no solo eso, 00:50:17
sino que me estoy empezando a 00:50:17
quitar un montón de cosas a 00:50:18
mogollón. 00:50:19
Es que ya hasta me sobra la 00:50:20
instalada. 00:50:22
Todo lo quito. 00:50:23
Pongo aquí un retún y esto lo 00:50:24
saco de live. 00:50:26
O sea, 00:50:27
es que al final se me está 00:50:27
quedando en nada. 00:50:28
Primero llevo una versión 00:50:30
estructurada en la que he 00:50:31
pensado, 00:50:31
pero tengo que hacer esto. 00:50:32
Y ahora ya no entendéis lo que 00:50:33
está pasando, ¿no? 00:50:36
Ahora ya, 00:50:37
cuando yo ya he hecho este for, 00:50:38
si la aplicación está instalada, 00:50:39
es que ya no tengo más que 00:50:41
hacer. 00:50:42
Es que ya he acabado porque ya 00:50:42
la he actualizado. 00:50:43
Con lo cual, 00:50:45
puedo hacer aquí un retún 00:50:45
estupendamente. 00:50:46
Porque si está instalada, 00:50:49
es que ya se acabó. 00:50:50
Ya no hay más que hacer. 00:50:52
Ya la he actualizado y el método 00:50:53
puede salir de ahí fuera 00:50:54
método. 00:50:55
Se acabó. 00:50:56
Entonces, si he hecho un retún, 00:50:57
este if ya no hace ninguna falta. 00:50:58
Porque si llega ahí es porque no 00:51:00
estaba instalada. 00:51:02
Entonces, 00:51:04
este if ya no hace ninguna falta 00:51:04
si yo hago un retún. 00:51:06
Y si ese if no hace ninguna falta, 00:51:07
tampoco hace falta la variable 00:51:09
instalada. 00:51:10
Entonces, fue la variable 00:51:11
instalada. 00:51:11
Entonces, 00:51:12
ahora ya sí que me queda un 00:51:13
código más cortito. 00:51:14
Pero, claro, de partida, 00:51:17
llegar al código más compacto, 00:51:18
pues, no tiene por qué ser fácil. 00:51:20
¿Vale? 00:51:27
Es que ya me quito todo esto. 00:51:27
Me quito esto. 00:51:30
Me quito esto. 00:51:33
Y me quito esta llave, ¿verdad? 00:51:36
Que da la del if. 00:51:39
Y se me ha quedado un método muy 00:51:42
corto. 00:51:43
Se me ha quedado este for para 00:51:45
ver si está instalada. 00:51:47
Si lo está, actualiza y fuera. 00:51:47
Se acabó método. 00:51:49
Que llegamos aquí. 00:51:51
Llegamos aquí. 00:51:52
Ay, esto era. 00:52:02
Vale. 00:52:05
Ay, no me lo formatea. 00:52:10
Porque está. 00:52:13
Vale. 00:52:14
Que llegamos aquí. 00:52:14
Esto, venga, pues, 00:52:15
los quito a mano. 00:52:16
Que llegamos a este punto. 00:52:24
Es porque no hemos salido por el 00:52:26
retún. 00:52:27
Luego, si no hemos salido por el 00:52:28
retún, 00:52:29
es porque no está instalada. 00:52:29
Pues, es cuando hago este rollo. 00:52:30
Y ya está. 00:52:32
Entonces, me he quitado ahí un 00:52:33
montón de historias. 00:52:35
Y la he dejado compactada en esta 00:52:37
parte para actualizar si es que 00:52:39
existe. 00:52:41
Y en esta para meter la nueva si 00:52:43
es que no existe. 00:52:45
Vale, pero siempre hacedos un 00:52:56
diagrama de flujo en la cabeza. 00:52:59
Siempre hacedos un flujo. 00:53:00
Tengo que hacer esto. 00:53:02
Ah, vale. 00:53:03
Voy a hacerme esta pregunta. 00:53:03
Ahora que no, pues, hago esto. 00:53:05
Siempre seguid un pensamiento 00:53:06
estructurado. 00:53:08
De ahí viene el nombre de 00:53:10
programación estructurada. 00:53:10
Porque tiene que estar perfectamente 00:53:11
claro el flujo. 00:53:14
Otra cosa es que luego, 00:53:15
una vez que uno ya tiene su 00:53:16
diagrama de flujo, 00:53:17
diga, ah, vale, mira, pues, 00:53:19
esto no sé qué, 00:53:21
esto no sé cuántos. 00:53:21
Bueno, pues, 00:53:28
este método a falta de que hagamos 00:53:28
las pruebas y se vaya al garete, 00:53:30
estaría tan bien. 00:53:34
¿Vale? 00:53:39
Vamos a parar un segundito y así 00:53:43
nos dejo grabada la respuesta. 00:53:45
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
30 de enero de 2024 - 17:13
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
53′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
241.24 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid