Saltar navegación

Simulacto 230113 parte 3 - 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 17 de enero de 2023 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar la tercera parte de la solución del simulacro que os puse el viernes, ¿vale? 00:00:00
Entonces, todo lo que vais a decir mientras estoy grabando, asume que tengo vuestro consentimiento para grabaros. 00:00:07
Si no, levantáis la mano y paro, ¿vale? 00:00:17
Ok, entonces, el tercer punto es, voy a crear esta clase de aquí, la clase móvil. 00:00:19
La clase móvil tendrá que trabajar con App Store e App, ¿vale? 00:00:25
Entonces, vamos a ver qué nos piden 00:00:32
Nos pide la clase móvil, ¿vale? 00:00:34
Representa un móvil y tiene varias cosas 00:00:37
Primero, un array de aplicaciones instaladas 00:00:41
Entonces, yo quiero un array de aplicaciones que son las que ahora mismo están instaladas en mi móvil 00:00:44
¿Cómo lo hago? 00:00:49
Pues app 00:00:51
Array 00:00:53
Y lo llamamos 00:00:55
Por ejemplo 00:00:58
Mobile apps 00:00:59
Estas son las aplicaciones del móvil 00:01:01
¿Vale? 00:01:06
¿Y qué le pongo dentro? Pues no lo sé 00:01:07
Todavía nada ¿Vale? 00:01:09
Ya veremos como gestiono esto 00:01:11
¿Si? Pero a mi ahora me interesa 00:01:13
Saber que un objeto 00:01:16
Tiene dentro 00:01:18
Un array de aplicaciones 00:01:20
Que son las aplicaciones que me he bajado del App Store 00:01:21
Vale 00:01:24
¿Qué más tiene la aplicación móvil? 00:01:25
Dice, una capacidad máxima 00:01:28
Medida en gigabytes 00:01:30
Por ahora estamos utilizando enteros 00:01:31
Podemos utilizar double 00:01:33
Entonces, un int 00:01:34
Storage 00:01:36
¿Qué será? ¿Cuántos gigabytes de aplicaciones 00:01:37
Puedo instalar? Si intento instalar 00:01:43
Una nueva aplicación y no tengo espacio 00:01:45
Me tendrá que decir 00:01:47
Mira, no, oye, no lo puedo instalar 00:01:49
¿Sí? 00:01:51
Y finalmente tiene un App Store asociado 00:01:53
Como cuando yo me pillo un Android tengo el Google Play asociado 00:01:59
Cuando me pillo un iPhone tengo el Apple Store asociado 00:02:04
Pues también mi móvil tiene que saber dónde puedo sacar aplicaciones 00:02:07
Entonces tendrá un App Store 00:02:12
Tienda Apps 00:02:14
Estas son las tres cosas que crean un móvil 00:02:23
Es lo que caracteriza un móvil según lo que me ha mandado 00:02:30
A partir de allí tendré que desarrollar su comportamiento haciendo móviles 00:02:35
Haciendo métodos 00:02:40
Entonces, la primera cosa que necesito es crear un objeto móvil 00:02:42
Para crear un objeto móvil necesito un constructor 00:02:49
¿Cómo hago un constructor? 00:02:52
Constructor es similar a un método 00:02:56
Pero no tiene algo 00:02:57
Que se devuelve 00:02:59
Aquí no pongo void 00:03:02
String o cosa por el estilo 00:03:06
Y se tiene que llamar como la clase 00:03:07
Por lo tanto móvil 00:03:09
Ahora, yo tengo que crear 00:03:10
Este móvil 00:03:14
¿Qué necesito saber de un móvil? 00:03:15
¿Vale? 00:03:19
el objetivo de un constructor es inicializar estas aplicaciones que no están inicializadas 00:03:19
vale entonces me tengo que preguntar cuando crea un móvil nuevo que quiero darle vale primero estas 00:03:28
aplicaciones aquí no representan el sistema operativo las aplicaciones básicas vale nosotros 00:03:36
simulamos que nuestro móvil esté vacío al principio si luego tiene solo el sistema 00:03:41
operativo y yo le instalo las móvil que quiero por lo tanto este señor de aquí no se lo pasó 00:03:45
por parámetro lo creo yo directamente móvil apps es igual a new app de 10 porque 10 posiciones 00:03:51
porque me da la gana 00:04:10
¿vale? la idea es que esto 00:04:12
no sea 10, sea 1 00:04:15
y que cuando yo instale 00:04:17
más de una aplicación 00:04:21
pues él dinámicamente vaya creciendo 00:04:22
disminuyendo o lo que sea 00:04:25
¿vale? pero como esta es una cosa 00:04:27
avanzada y yo tengo poco tiempo 00:04:29
para hacer este examen 00:04:31
por ahora pienso fácil 00:04:32
y simplifico y digo 00:04:35
máximo puedo instalar 10 aplicaciones 00:04:37
Me da igual, si tienes 00:04:39
Estorage de 30 00:04:41
Cada aplicación ocupa 1 00:04:42
Podrías poner 30 00:04:44
¿Vale? Pero no, por ahora 00:04:46
No quiero pensar en ese problema 00:04:49
Por ahora simplemente básico 00:04:50
Pongo 10, si quiero 00:04:52
Pongo 30 en el sentido de que 00:04:54
Como mínimo hemos puesto que son enteros 00:04:57
Entonces como mínimo una aplicación 00:04:59
Podrá tener 1 de tamaño 00:05:01
Si pongo 30 aplicaciones 00:05:03
De 1, máximo caben 30 00:05:05
Ya está, solucionado 00:05:07
¿Vale? 00:05:08
Hablo de 30 porque luego en el ejemplo que me pone aquí dice de crear un móvil con 30 GB 00:05:10
¿Vale? Por lo tanto 00:05:17
Segundo atributo que quiero hacer 00:05:19
El atributo storage 00:05:24
¿Cómo hago storage? 00:05:25
¿Móviles distintos pueden tener tamaño distinto? 00:05:28
Eso sí, ¿vale? 00:05:35
Entonces, lo storage hago que me lo pasen por aquí 00:05:37
int storage 00:05:40
y le digo que 00:05:42
this.storage 00:05:44
es igual a 00:05:46
storage 00:05:49
ya está 00:05:49
repito, el objetivo de este 00:05:55
constructor es rellenar 00:05:57
estas tres aplicaciones 00:06:00
y estos tres atributos 00:06:02
perdón, entonces este atributo de aquí 00:06:04
lo estoy rellenando 00:06:06
yo, como me da la gana 00:06:08
todos los móviles del mundo 00:06:10
Tendrán esto al principio 00:06:12
Esto he decidido que no 00:06:14
Que no lo decido yo, sino que lo va a decidir 00:06:18
Quien crea el móvil 00:06:20
Quien crea el móvil me tiene que pasar 00:06:22
Cuanto tamaño, cual es el tamaño de su memoria 00:06:24
Vale, y yo lo pondré aquí dentro 00:06:26
Y ahora me queda esto 00:06:29
Quien decide 00:06:31
Cuales son las aplicaciones 00:06:33
Vale, cuales son el Apple Store 00:06:36
El App Store 00:06:39
Y puedo tener dos opciones 00:06:40
O al crear un móvil 00:06:42
El móvil se crea su propio App Store 00:06:45
Desde fuera 00:06:50
Cuando llamaré un nuevo móvil 00:06:52
Lo que haré es pasarle 00:06:54
Un App Store 00:06:57
Como parámetro 00:06:58
Y entonces el App Store lo crearé fuera 00:06:59
Y luego se lo pasaré a mis 00:07:02
A mis móviles 00:07:03
Hagamos que 00:07:07
La App Store me viene desde fuera 00:07:08
Esto me da la ventaja 00:07:11
Que no todos los App Store del mundo 00:07:15
Tienen que tener 00:07:17
O sea, no todos los móviles del mundo 00:07:17
Tienen que tener el mismo App Store 00:07:19
Sino que podría crear 7 App Store distintos 00:07:21
Y cuando crea un nuevo móvil 00:07:23
Decir cual de los App Store 00:07:25
Va utilizando 00:07:27
App Store 00:07:28
Tienda Apps 00:07:30
Y aquí haré 00:07:34
This.TiendaApps 00:07:37
Es igual a tienda apps 00:07:41
De esta forma, cuando yo creo un móvil nuevo 00:07:44
Le tengo que pasar estos dos parámetros 00:07:49
Y se me inicializan todos los atributos de estos móviles 00:07:51
No puede haber móviles que no tengan estos atributos inicializados 00:07:57
Porque para crear un móvil tengo que pasar por aquí 00:08:02
Y esto está inicializando todo 00:08:05
Ahora, ¿podría inicializarla nul? 00:08:07
Sí 00:08:09
Pero inicializar la null es una inicialización 00:08:09
Aceptable 00:08:12
Ten cuidado con lo que haces 00:08:13
Porque luego cuando intentas utilizar ese objeto 00:08:15
Te dará un null pointer exception 00:08:18
Pero me vale 00:08:19
¿Si? 00:08:21
No me acuerdo 00:08:25
Quería decir algo más 00:08:28
Podría hacer 00:08:29
Otros constructores distintos 00:08:32
¿Vale? Podría hacer un constructor 00:08:34
Que no recibe el app store y da un app store 00:08:36
por defecto, si quieres hacerlo 00:08:38
porque no, vale, tanto estamos 00:08:40
aquí, entonces 00:08:42
en este otro 00:08:43
constructor 00:08:45
lo que hago es te doy solo el tamaño 00:08:46
y entonces te asocio 00:08:50
a la tienda apps 00:08:52
no, esto no lo 00:08:54
tengo, porque no me lo han pasado 00:08:56
entonces tendré que crearle un objeto 00:08:57
me llama esto 00:09:01
lo diré, app store 00:09:03
vale, entonces será un 00:09:06
New 00:09:08
App Store 00:09:14
Y al App Store le tengo que pasar por aquí 00:09:18
Un código 00:09:22
Parecido 00:09:24
A este de aquí 00:09:25
Que hemos visto antes 00:09:27
¿Vale? 00:09:29
Entonces ya que estoy me copio esto 00:09:30
Que es el ejemplo que me ha dado el enunciado 00:09:33
Y se lo paso 00:09:35
Como parámetro 00:09:39
Como string 00:09:41
¿Vale? 00:09:43
Entonces ahora este App Store de aquí 00:09:45
Me creará un App Store 00:09:47
Con dentro Minecraft 00:09:50
Con dentro Loves of Legend 00:09:51
Con dentro Fortnite, con dentro Tok Tok 00:09:53
Y todo eso 00:09:55
¿Si? 00:09:56
La diferencia entre estos dos constructores 00:09:59
Es que esto me permite 00:10:02
Modificar también el App Store 00:10:03
Mientras este de aquí el App Store me da esto por defecto 00:10:05
Todos los que cree con este constructor 00:10:07
Tendrán este mismo 00:10:09
App Store 00:10:11
Pregunta, ¿qué hago con estas cosas de aquí? 00:10:12
¿Las dejo así o las pongo privadas? 00:10:19
Por ejemplo, estas de aquí que son las aplicaciones que yo pongo aquí dentro 00:10:33
Si me leo el enunciado veo que hay cosas como GetUp o RemoveUp 00:10:38
Que son para añadir una aplicación o quitar una aplicación 00:10:43
Entonces no quiero que la gente acceda directamente a este array y que lo modifique 00:10:48
Quiero que para modificar este array se pase por mi getApp o por mi removeApp 00:10:54
Por lo tanto lo pongo privado 00:11:02
Desde fuera de esta clase no se puede acceder a esta variable 00:11:07
Quiero que alguien después de haber creado un móvil 00:11:12
Le pueda cambiar el tamaño de la memoria 00:11:17
Tampoco, yo quiero que se sete al principio 00:11:19
Y luego no se pueda modificar 00:11:24
Por lo tanto lo pongo private 00:11:27
Entonces aquí es donde se define el storage del móvil 00:11:29
Y luego la memoria del móvil no puede cambiar 00:11:35
Y quiero que se pueda cambiar el App Store 00:11:37
A lo mejor podría ser interesante 00:11:42
Por si hago una actualización del App Store 00:11:44
Podérselo modificar 00:11:46
Depende de si quiero que puedan acceder 00:11:47
Directamente a esto 00:11:51
O si tengan que pasar 00:11:53
Por un método que a lo mejor hace 00:11:55
Algún tipo de control que le proporciono yo 00:11:56
Pues así 00:11:59
Porque no sé muy bien que hacer 00:12:00
Pues lo dejo por ahora libre 00:12:02
¿Vale? 00:12:04
Normalmente deberíamos tender 00:12:06
A que todos estos sean privados 00:12:08
Y que si alguien quiere modificar 00:12:10
Algo de mi clase 00:12:14
Tenga que pasar por un método 00:12:16
Que yo le proporciono 00:12:18
Que hace los controles suficientes 00:12:19
Para decir si el valor 00:12:22
Que me has pasado y le quieres meter 00:12:24
Es correcto o no 00:12:25
¿Vale? Entonces técnicamente 00:12:27
Esto normalmente se tende 00:12:30
Que sean todos privados 00:12:32
Pero bueno 00:12:33
Entonces tengo mi móvil 00:12:34
Y tengo la posibilidad de crear móviles 00:12:39
vale, fenomenal 00:12:42
vamos ahora a hacerle hacer algo 00:12:43
a esto 00:12:46
la clase móvil puede hacer 00:12:46
la primera cosa es navegar app store 00:12:49
navegar app store quiere decir que yo accedo al app store 00:12:51
y miro que aplicaciones hay 00:12:54
para que luego pueda yo bajarme 00:12:56
una de estas aplicaciones 00:12:57
vale, fenomenal 00:12:59
public 00:13:00
voy a mirar un momento app store 00:13:04
porque yo aquí tengo un list app 00:13:11
list app que es el que me lista 00:13:13
las aplicaciones 00:13:17
es una aplicación que devuelve 00:13:19
un string, vale 00:13:22
entonces yo aquí voy a hacer que 00:13:23
sea el móvil el que imprime 00:13:25
en pantalla, vale, o sea el móvil cuando yo le digo 00:13:27
hazme ver las aplicaciones 00:13:30
se conecta al App Store 00:13:31
el App Store le dirá el listado 00:13:33
de las aplicaciones, que es una cosa que ya 00:13:35
he hecho porque ya existe, y yo 00:13:37
móvil lo hago ver a mi 00:13:39
usuario, vale, por lo tanto 00:13:41
esto no devuelve nada 00:13:44
Se llama 00:13:45
Navigate 00:13:48
No me equivoco, no, navegar 00:13:50
App Store 00:13:52
Navegar 00:13:53
App Store 00:13:56
No recibe nada 00:13:58
Porque el App Store al que voy 00:14:00
A mirar 00:14:02
Es el que tengo yo aquí 00:14:04
Y lo único que tengo 00:14:06
Que hacer aquí dentro es 00:14:08
Imprimir por pantalla 00:14:10
tienda apps 00:14:15
punto 00:14:17
lista 00:14:19
ya lo tengo 00:14:21
el método que me lista 00:14:26
todas las aplicaciones 00:14:28
dentro de un app store 00:14:29
entonces lo único que tengo que hacer 00:14:31
es llamar ese método 00:14:34
que es sobre mi app store 00:14:36
llamo 00:14:38
el método que me lista todas las aplicaciones 00:14:39
de ese app store, vale, fenomenal 00:14:42
Y luego lo que hago, como esto me devuelve un string, pues lo que hago es imprimirlo en pantalla. 00:14:44
¿Dudas? 00:14:56
A este punto ya puedo empezar public void main string args a hacer un pequeño main para probar mis móviles. 00:14:56
Vale, entonces me creo 00:15:18
Un main, public stack 00:15:21
Me creo en mi main 00:15:23
Y en el main que hago 00:15:27
Móvil, móvil 1 00:15:28
Es igual a new 00:15:31
Móvil 00:15:32
De 30 GB 00:15:33
Y nada más 00:15:37
Entonces esto me ha creado un móvil M1 00:15:39
Y ahora yo puedo decir 00:15:44
M1 punto 00:15:45
Navegar 00:15:47
App Store 00:15:49
Esto me debería imprimir en pantalla 00:15:50
La información que está contenida en este App Store que he creado 00:15:58
Vamos a ver si es verdad 00:16:07
Aquí lo tengo 00:16:08
Fijaos que esto lo está escribiendo el móvil 00:16:10
Desde el main preguntando al móvil que me escriba las aplicaciones a las que tiene acceso 00:16:15
Quiero ser, ya que tengo esto aquí 00:16:21
Puedo decir 00:16:25
Soy 00:16:26
Un móvil 00:16:30
De capacidad 00:16:33
Más 00:16:37
Storage 00:16:43
No hemos puesto 00:16:45
Nada que identifique un 00:16:53
Un móvil 00:16:54
¿Vale? Por lo tanto no puedo poner 00:16:57
Soy el móvil X 00:16:59
Porque no tengo aquí modelo 00:17:00
no tengo aquí serial number, no tengo nada 00:17:02
no lo he puesto, vale, por lo tanto 00:17:04
lo único que puedo hacer es 00:17:06
decir que soy un móvil con 00:17:08
mi capacidad esta de aquí 00:17:10
y cosas por el estilo, vale, esto para que 00:17:12
veáis que lo que se está 00:17:14
escribiendo es el método 00:17:16
del móvil, no 00:17:18
el método del 00:17:20
App Store, vale 00:17:22
pero el móvil 00:17:24
lo que hace es 00:17:26
acceder al método 00:17:27
Del App Store 00:17:31
Recibe un string 00:17:32
Donde está toda la secuencia 00:17:35
Del listado 00:17:37
Y lo que hace es 00:17:38
Imprimir una en pantalla 00:17:40
Realmente no me pongo 00:17:41
Yo ahora a acceder 00:17:45
A este array de aquí 00:17:47
Al array apps 00:17:49
Del App Store 00:17:51
Y empezar a leer cada una de ellas 00:17:52
Porque esto ya lo he hecho 00:17:55
App Store ya me proporciona 00:17:56
Es la posibilidad de hacer un listado 00:17:58
De las aplicaciones 00:18:01
Por lo tanto uso ese método 00:18:02
Uso el método que está en aplicación 00:18:04
En concreto está 00:18:05
Este método de aquí, lista 00:18:08
Que ya está implementado 00:18:10
¿Dudas? 00:18:13
Vale 00:18:19
Entonces navegar a App Store 00:18:20
Ya está hecho, esto me servirá porque 00:18:24
Al usuario navegará al App Store 00:18:26
Mirará todas las aplicaciones que tiene 00:18:28
Tiene estas aplicaciones aquí y ahora 00:18:30
Decidirá, vale, instálame 00:18:32
logs of legend 00:18:34
y él intentará instalar logs of legend 00:18:35
o instálame whatsapp 00:18:38
vale 00:18:41
siguiente método 00:18:45
get up 00:18:48
public 00:18:50
void 00:18:53
get 00:18:54
con 00:18:58
pilla una string vale que será 00:19:00
string 00:19:03
name 00:19:04
Este de aquí 00:19:06
Lo que tiene que hacer 00:19:09
Es instalar 00:19:11
En mi 00:19:13
Array de aplicaciones 00:19:15
Que son las aplicaciones instaladas en el móvil 00:19:18
Tiene que instalar 00:19:21
La que tenga name 00:19:23
Pasado por aquí 00:19:25
¿Vale? 00:19:27
Entonces 00:19:31
La primera cosa que voy a hacer 00:19:31
Es buscar 00:19:34
Este nombre 00:19:35
En el App Store 00:19:37
Y que el App Store 00:19:39
Me devuelva una copia 00:19:41
De esa aplicación 00:19:43
¿Vale? 00:19:45
Una copia, no quiero una referencia 00:19:47
Al objeto del App Store 00:19:50
Quiero bajarme 00:19:51
Copiarme esa aplicación 00:19:53
¿Vale? 00:19:55
Y yo tengo ya un método que me hace esto 00:19:56
El método install 00:19:59
El método install 00:20:00
Al que le paso un nombre 00:20:05
Lo que hace es 00:20:06
Me busca 00:20:08
La aplicación 00:20:09
Y si la encuentra 00:20:11
Me devuelve una copia 00:20:14
Si no la encuentra 00:20:15
Me devolverá null 00:20:18
Por lo tanto 00:20:19
Yo aquí lo único que tengo que hacer es 00:20:22
App 00:20:24
Nueva app 00:20:24
La que quiero instalar ahora 00:20:26
Es igual a 00:20:30
Tienda apps 00:20:33
Accedo a mi 00:20:35
App Store 00:20:37
¿Vale? 00:20:41
Punto install 00:20:43
Que es el método que me permite copiarme 00:20:45
Las cosas 00:20:48
De el nombre que me ha dado el usuario 00:20:49
El nombre que se me ha dado 00:20:52
¿Vale? 00:20:54
Entonces, si esto funciona 00:20:56
Cuando he hecho esto 00:20:58
Aquí dentro tendré 00:21:03
Una referencia 00:21:05
A una copia de mi aplicación 00:21:07
Que está en el App Store 00:21:10
Se copia 00:21:11
Se crea una copia de este mismo 00:21:12
O sea, otro objeto con los mismos 00:21:15
Valores dentro 00:21:17
Y yo ahora tendré una referencia 00:21:18
A este nuevo objeto 00:21:21
Esto lo dejo en paz 00:21:22
Entonces, ¿qué hago ahora? 00:21:24
Pues, la primera cosa 00:21:32
Que tengo que comprobar es 00:21:34
Exacto 00:21:36
Es comprobar 00:21:49
Si esta cosa de aquí es null 00:21:51
Porque si es null 00:21:53
Quiere decir que yo he pedido una aplicación 00:21:55
Que no existe en el App Store 00:21:57
Y por lo tanto no la voy a instalar en mi móvil 00:21:58
¿Sí? 00:22:01
Entonces 00:22:04
Nueva app 00:22:06
Is not null 00:22:08
Entonces ahora voy a instalarla 00:22:11
En mi móvil 00:22:15
Si no, no hago nada 00:22:16
Si yo te pido una aplicación que no está en el móvil 00:22:17
Al máximo le puedo hacer una cosa como else 00:22:22
Y escribir un mensaje de error de la aplicación 00:22:24
Error 00:22:32
No se puede instalar la aplicación 00:22:33
Más nombre 00:22:42
Más name 00:22:45
Si lo que me ha devuelto es un null 00:22:46
Entonces entrará aquí y diré 00:22:50
Ha habido un error 00:22:52
Me ha salido un error en el móvil 00:22:53
Dice no puedo instalar la aplicación que me has pedido tú 00:22:55
A lo mejor es que me has pedido una aplicación que no está en el App Store 00:22:57
Probablemente 00:23:01
¿Vale? 00:23:02
Si en vez 00:23:04
La nueva aplicación me ha llegado 00:23:06
Y es correcta 00:23:09
¿Vale? 00:23:10
Ahora tengo aquí esta 00:23:11
No la he instalado todavía en el móvil 00:23:12
¿Vale? 00:23:15
Porque para instalarla en el móvil la tengo que copiar 00:23:15
Aquí dentro 00:23:18
¿Sí? 00:23:19
Entonces 00:23:24
La primera cosa que tengo que hacer 00:23:25
¿Qué es? 00:23:28
Bueno, vamos a hacerlo sencillo, luego lo mejoramos, lo complicamos, ¿vale? 00:23:35
La instalo, instalémosla. 00:23:40
¿Cómo instalo esta en mi móvil? 00:23:43
Pues en móvil apps, de cero, le pongo nueva app. 00:23:49
Ya está, instalada. 00:24:00
¿Cuántos millones de problemas tenemos aquí? 00:24:03
Decidme uno y lo resolvemos. 00:24:07
Esto para vosotros funciona 00:24:09
Vale, instalo una aplicación 00:24:23
Pues me la instala, fenomenal 00:24:26
Instalo otra aplicación, ¿qué pasa? 00:24:27
Que me la vuelva a meter 00:24:31
Entonces me machaca 00:24:33
La aplicación que tenía antes y me instala la nueva 00:24:35
Con este método puedo instalar 00:24:37
Una sola aplicación y siempre en posición 00:24:39
Cero de Movilabs 00:24:41
¿Quiero que sea así? No 00:24:43
Por lo tanto 00:24:44
¿Qué hago? 00:24:47
For 00:24:50
hagamos un for 00:24:50
y que hago en este for 00:24:54
menos de que 00:24:56
de la capacidad del array 00:25:05
entonces mobileapps.lang 00:25:14
y más más 00:25:18
y que hago en esto 00:25:21
mobileapps 00:25:34
mobileapps de i 00:25:36
es null 00:25:38
entonces 00:25:45
esto lo quito 00:25:51
¿Así funciona? 00:26:03
Pregunto 00:26:16
¿Sí? 00:26:17
Ok, a ver, posición 0 es null 00:26:22
Se la escribo 00:26:24
Posición 1 también es null 00:26:27
Se la escribo 00:26:28
Posición 2 es null 00:26:29
Posición 3 es null 00:26:31
Posición 4 es null 00:26:33
Se la escribo 00:26:35
Esto me copia esto 00:26:36
En todas las celdas 00:26:39
La primera vez que instalo una aplicación 00:26:43
Me la copia 30 veces 00:26:46
Entonces, ¿qué hago? 00:26:48
O aquí le pongo 00:26:58
Que i es igual a 00:26:59
MobileApps.length 00:27:02
Salgo 00:27:03
Y otra opción 00:27:04
Que ya hemos hecho 50 veces en ejercicios anteriores 00:27:07
Boolean 00:27:09
Espacio 00:27:11
Encontrado 00:27:13
Es igual a 00:27:15
False 00:27:18
Si entro aquí dentro, espacio encontrado se vuelve true 00:27:18
Y yo me quedo ciclando en este for mientras que esto sea verdadero 00:27:27
Y también espacio encontrado 00:27:35
Perdón, not espacio, y no haya encontrado el espacio 00:27:40
En el momento en que esto se vuelve true 00:27:45
Porque ya he puesto 00:27:50
Esto en algún espacio vacío 00:27:52
Esto se vuelve falso 00:27:54
Por lo tanto 00:27:56
Todo esto es falso 00:27:58
Y por lo tanto me sale del for 00:27:59
Y no me lo copio 30 veces 00:28:01
Lo repito con más calma 00:28:04
¿Sí? 00:28:08
Vale 00:28:10
Hago este for 00:28:11
No es la primera vez que lo hacemos 00:28:14
Con dos condiciones 00:28:15
La primera es que me voy recorriendo el array, vale 00:28:17
Pero también me acuerdo si he encontrado o no el espacio para meter mi aplicación 00:28:20
Que al principio no lo he encontrado, por lo tanto es falso 00:28:26
Entonces, cuando voy a esta condición 00:28:29
Esta condición entera, o sea todo esto 00:28:33
Es true si, solo si, esta parte y también esta parte 00:28:37
Son true las dos 00:28:47
¿Vale? 00:28:49
Porque tengo un i 00:28:50
Un end en el medio 00:28:52
¿Si? 00:28:54
Entonces 00:28:57
Esto, si os fijáis 00:28:57
Es not 00:29:00
El inverso de esto 00:29:01
Por lo tanto, si este es falso 00:29:04
Este es true 00:29:06
Es decir, que mientras 00:29:07
Que no haya encontrado esto 00:29:10
Quédate aquí dentro dando vueltas 00:29:13
Yo me quedo dando vueltas aquí en dos casos. El primer caso es mientras que i sea menor del tamaño de mi array. Entonces voy aumentando ese i. Y por otro lado, mientras que no haya encontrado todavía un espacio. 00:29:15
En cuanto haya encontrado un espacio 00:29:33
Le voy a poner true aquí 00:29:36
De esta forma esto se vuelve falso 00:29:39
Y cualquier cosa y falso me dará falso 00:29:42
Y por lo tanto saldré del for 00:29:46
De esta forma evito que no entre 00:29:48
Una vez que haya encontrado una celda 00:29:53
Y haya metido allí la aplicación 00:29:54
No vaya a probar las celdas siguientes 00:29:56
Ya la ha encontrado, ya la ha puesto allí y se acabó 00:29:59
¿Dudas? 00:30:01
Entonces 00:30:12
Cuando yo estoy aquí dentro 00:30:12
Mi programa lo que hará es 00:30:18
Ir a mirar todas las 00:30:22
Celdas a la búsqueda de una 00:30:24
Que sea null 00:30:26
Si encuentra una que es null, mete allí 00:30:27
La aplicación nueva 00:30:30
Y marca que ya lo ha hecho 00:30:31
Y por lo tanto acaba el proceso 00:30:34
Si en vez 00:30:36
No encuentra un espacio 00:30:37
llegará hasta el final sin haberla encontrado 00:30:40
y entonces mi espacio encontrado se quedará falso 00:30:44
es decir que cuando yo salgo de este for 00:30:47
puedo tener dos opciones 00:30:50
o espacio encontrado es true 00:30:52
y eso quiere decir que ha conseguido instalar la aplicación 00:30:55
o el espacio encontrado es falso 00:30:59
y eso quiere decir que ha mirado todos los espacios 00:31:02
y no ha encontrado espacio 00:31:05
justo 00:31:09
y ahora tendré que gestionar esto 00:31:11
espacio 00:31:26
encontrado 00:31:29
iso 00:31:33
app 00:31:38
instalada 00:31:40
si cuando llego aquí 00:31:42
bueno, este boolean 00:31:49
entonces 00:31:51
no, debería funcionar 00:31:52
espacio 00:31:58
Si espacio encontrado 00:32:02
Es true 00:32:05
Esto quiere decir que si esta cosa vale true 00:32:06
Quiere decir que ha podido encontrarlo 00:32:09
Ya está fenomenal y yo le escribo 00:32:11
Oye, la aplicación ha sido instalada correctamente 00:32:13
¿Vale? 00:32:15
Instalada 00:32:17
Correctamente 00:32:17
Si no 00:32:20
Si eso 00:32:22
Error 00:32:28
No he podido 00:32:30
Instalar 00:32:36
Más name 00:32:38
En teoría puedo hacer esto 00:32:43
En teoría no 00:32:48
En teoría tengo que encontrarme una forma 00:32:49
Para que se instale igualmente 00:32:52
Pero como estoy en un examen 00:32:53
Y tengo poco tiempo 00:32:56
Por ahora lo dejo así 00:32:57
Ya veré con el tiempo si quiero complicarme 00:32:59
Por ahora simplemente digo 00:33:03
Que yo tenía 30 espacios 00:33:04
Se lo he puesto aquí 00:33:05
Yo tengo 30 espacios 00:33:06
si por si acaso 00:33:09
me intentan instalar 31 00:33:13
aplicaciones 00:33:15
pues la 31 me dirá 00:33:16
no la puedo instalar 00:33:19
tengo un límite no tanto de espacio 00:33:20
que también lo tengo, pero tengo 00:33:23
un límite de número de aplicaciones 00:33:25
que puedo instalar en un cierto momento 00:33:27
y si no puedo 00:33:29
me dice que no puedo, ya está, no hace nada 00:33:31
y se acabó 00:33:33
para instalar 00:33:35
la nueva aplicación tendré que desinstalar 00:33:37
alguna vieja, la alternativa 00:33:39
sería que cuando yo no puedo 00:33:41
pues aumente el tamaño 00:33:43
de este array 00:33:45
copie todo, las 30 posiciones 00:33:47
que ya estaban en un array nuevo 00:33:49
de 60 y ahora tenga un array 00:33:51
de 60 veces que de 30 00:33:53
pero por ahora no lo hacemos 00:33:54
lo hacemos después 00:33:57
por ahora me interesa otra 00:33:58
cosa que es más 00:34:01
relevante para este ejercicio 00:34:02
que es el 00:34:05
y ahora lo he instalado 00:34:06
Pero en ningún momento 00:34:09
Aquí he comprobado si puedo 00:34:11
Instalarlo o no 00:34:13
¿Cuándo puedo instalarlo? 00:34:14
Cuando tengo espacio 00:34:20
¿Sí? 00:34:21
Entonces 00:34:25
¿Cómo hago para saber 00:34:26
Cuánto espacio me queda? 00:34:28
Dos opciones 00:34:31
O cada vez que me hace falta 00:34:41
Me lo calculo 00:34:43
O tengo constancia de él 00:34:44
De alguna forma con una variable 00:34:47
por algún lado 00:34:49
¿vale? como nosotros hemos decidido 00:34:51
que estos son nuestros atributos 00:34:53
y no quiero meter otros 00:34:55
si no es estrictamente necesario 00:34:57
pues quiere decir que cada vez que necesito 00:34:59
esta información me la calcularé 00:35:01
¿vale? 00:35:03
entonces, ya que estamos 00:35:05
como esto me suena que luego lo tengo 00:35:07
que volver a reutilizar en status 00:35:09
¿vale? porque dice 00:35:11
indica cuanto espacio libre 00:35:13
tengo, pues entonces me voy a hacer 00:35:14
un metodito por algún lado 00:35:17
Que lo que hace es calcularme 00:35:19
Cuanto espacio me queda 00:35:20
¿Vale? 00:35:21
Entonces public int 00:35:23
Storage 00:35:26
Restante 00:35:31
¿Cómo se dice? 00:35:35
Storage remanente 00:35:37
Restante 00:35:39
Storage left 00:35:40
Mezclamos aquí inglés y español 00:35:42
Porque nos da la gana 00:35:45
¿Vale? 00:35:46
int 00:35:49
es igual a 0 00:35:53
return sl 00:35:54
vale, entonces 00:35:56
como calculo 00:35:58
cuanto storage me queda 00:36:00
acedo 00:36:02
a cada una de las aplicaciones 00:36:05
que tengo instaladas 00:36:07
me voy acumulando 00:36:09
cuanto pesa cada una de ellas 00:36:11
y después 00:36:14
resto 00:36:16
mi storage máximo 00:36:18
al número que es acá 00:36:20
¿cómo calculo 00:36:22
cuántas 00:36:24
cuántas aplicaciones 00:36:25
tengo instaladas? ¿cuánto pesan 00:36:28
las aplicaciones que tengo 00:36:30
instaladas? ¿cómo va? 00:36:32
con un for 00:36:35
95% 00:36:40
la respuesta del 95% 00:36:42
de la pregunta que hago es con un for 00:36:45
int 00:36:47
y es igual a 0 00:36:48
y menor que qué 00:36:50
donde tengo instaladas mis aplicaciones 00:36:52
como se llama el array 00:36:58
movilabs 00:37:01
voy a este array que es 00:37:06
las aplicaciones que tengo 00:37:08
instaladas 00:37:10
.lang 00:37:11
y mas mas 00:37:14
vale 00:37:17
entonces a partir de la primera 00:37:20
hasta la ultima 00:37:23
posiciones de este array 00:37:25
lo que hago es 00:37:27
acceder a un cierto 00:37:29
campo 00:37:32
¿Vale? 00:37:32
Por ejemplo 00:37:34
movilabs 00:37:35
de i 00:37:37
punto 00:37:41
size 00:37:42
Esto es 00:37:45
el tamaño 00:37:48
de la aplicación 00:37:50
en posición i 00:37:52
Fijaos que no me permite pillarlo 00:37:53
porque si os acordáis 00:37:56
app 00:37:58
No, app no es 00:37:58
¿Qué he dicho mal? 00:38:01
A lo mejor porque todavía no está completada la expresión 00:38:03
¿Qué hago con esto? 00:38:21
¿Dónde lo pongo? 00:38:24
En SL, ¿no? 00:38:28
¿No estamos calculando los storage left? 00:38:29
No, bueno, en SL va a ser así 00:38:31
En otra variable int 00:38:33
Espacio ocupado 00:38:35
El error es 0 00:38:40
Entonces, espacio ocupado es igual 00:38:45
A esto 00:38:50
¿Correcto? 00:38:51
Pero antes que eso 00:38:53
Yo tengo que acumular 00:38:59
El tamaño allí 00:39:04
Voy recorriendo todas las aplicaciones 00:39:06
Y voy acumulando 00:39:16
En espacio ocupado el tamaño 00:39:17
De cada una de las aplicaciones 00:39:19
¿Vale? 00:39:21
De esta forma cuando llegare aquí 00:39:22
¿Cuánto valdrá? 00:39:27
El storage le debería ser la capacidad máxima 00:39:29
Es como cálculo 00:39:36
como se calcula storage left 00:39:37
this.storage 00:39:40
menos 00:39:45
espacio ocupado 00:39:48
os torna esto 00:39:50
os parece correcto 00:39:56
independientemente de que 00:39:59
todavía tenemos que afinar una cosa 00:40:01
me voy mirando todas las aplicaciones 00:40:03
voy acumulando 00:40:08
en espacio ocupado 00:40:09
El tamaño de cada una de las aplicaciones 00:40:11
Entonces cuando salgo de este 00:40:14
For en espacio ocupado 00:40:15
Tengo la suma de todos los espacios 00:40:17
Ocupados de todas las aplicaciones 00:40:19
Pillo mi tamaño 00:40:21
Máximo, mi memoria, le quito 00:40:24
La parte ocupada y tengo 00:40:25
Aquí en SL, Storage Left 00:40:27
O sea, el tamaño 00:40:29
Que me queda libre 00:40:32
¿Por qué esto no funciona y explota? 00:40:32
Si uno cualquiera de los espacios de movilapps es null 00:40:38
O sea que puedo hasta tener 10 aplicaciones instaladas 00:40:52
Pero luego tengo 20 espacios a null 00:40:56
Cuando intento hacer esto 00:40:59
Si esto vale null 00:41:02
Explotará con un null pointer exception 00:41:07
Intenta acceder 00:41:11
Al campo size de un objeto 00:41:14
Que es null 00:41:16
Entonces no le gusta 00:41:17
O sea que yo esta cosa de aquí 00:41:18
La tengo que hacer 00:41:22
Si, solo si 00:41:24
Queda claro esto 00:41:25
Yo tengo mi array de apps 00:41:49
Tengo mi array de apps 00:41:53
Estas son todas apps 00:42:00
¿Vale? 00:42:02
Algunas podrán ser apps reales 00:42:03
Pero luego estará null 00:42:05
Null, null 00:42:08
Null 00:42:10
Null 00:42:12
Y yo lo que voy a hacer es 00:42:13
Accedo a un campo, el campo 0 00:42:16
Si esto es not null 00:42:18
Entonces me saco su size 00:42:20
Y lo sumo 00:42:22
Si este es not null 00:42:24
El campo 1 00:42:27
Saco el size 00:42:28
Y lo sumo 00:42:29
Si este es null, no hago nada, me lo salto 00:42:31
Si es null es porque o no ha habido nada nunca o han borrado esa celda 00:42:34
Y esto también como lo hago aquí depende de como luego borraré las aplicaciones 00:42:45
Porque si yo simplemente si quiero, imaginamos que yo tengo estas cuatro instaladas 00:42:53
Si yo cuando borro esta simplemente lo que hago es poner aquí null 00:42:59
Entonces podría haber null 00:43:03
En el medio 00:43:07
¿Vale? 00:43:08
Entonces tengo que tener cuidado 00:43:10
Si en vez 00:43:12
Lo que hago es que cuando 00:43:14
Rompo esta 00:43:16
Si hay aplicaciones después 00:43:18
Las muevo 00:43:21
Hacia adelante y recompacto todo 00:43:22
Pues entonces puedo estar seguro 00:43:25
Que cuando encuentro un null 00:43:27
Ya puedo salir 00:43:28
Porque no hay ninguna después 00:43:29
Depende de cómo yo hago las cosas 00:43:32
¿Vale? 00:43:34
Por ahora todavía no lo he pensado 00:43:36
Por lo tanto lo hago de la forma más sencilla 00:43:37
Leo todo 00:43:39
Y si es null me lo salto 00:43:41
Y si no es null lo sumo 00:43:42
Ya está, no tengo problemas 00:43:44
¿Es menos eficiente? 00:43:45
Sí 00:43:48
Pero funciona 00:43:48
¿Sí? 00:43:50
Entonces vamos a probarlo 00:43:52
Ah, no, perdón 00:43:53
Esto me servía porque estaba a mitad del otro 00:44:00
Perdón 00:44:03
Acabamos esto de aquí 00:44:03
En GetApplication 00:44:06
Habíamos dicho que 00:44:08
Todo esto lo hacíamos 00:44:09
Si, solo si 00:44:12
Tengo espacio 00:44:13
En el móvil 00:44:15
Si no tengo espacio en el móvil 00:44:17
Pues no hago nada 00:44:19
Justo 00:44:20
Entonces 00:44:21
Si, os acordáis 00:44:23
Yo intento instalarla, me dan una copia 00:44:27
Vale, fenomenal 00:44:29
Si la copia es null 00:44:30
Digo que es un error 00:44:32
Si la copia no es null 00:44:34
O sea, la he encontrado en el App Store 00:44:37
Entonces, todo esto 00:44:39
Lo que hacía era instalármela 00:44:41
¿Vale? 00:44:43
Pero ahora, yo todo esto 00:44:45
Lo tengo que hacer solo si tengo espacio libre 00:44:47
Entonces 00:44:50
Todo esto 00:44:53
¿Sí? 00:44:56
Todo esto 00:45:00
Lo hago solo si 00:45:03
como me pregunto 00:45:04
si tengo espacio libre 00:45:10
si tengo espacio suficiente para instalar 00:45:11
esta aplicación 00:45:14
repito la pregunta 00:45:15
este código de aquí que hemos hecho antes 00:45:26
lo que hace es instalarme 00:45:29
la aplicación 00:45:31
en un espacio vacío de mi 00:45:33
array 00:45:35
de mi array de aplicación 00:45:36
vale, esto ya está hecho 00:45:39
pero yo esto no lo puedo hacer siempre 00:45:41
Lo puede hacer solo si la aplicación que estoy buscando no es null 00:45:43
O sea, existe y está aquí 00:45:48
Y también si tengo espacio suficiente para poner esta aplicación en mi móvil 00:45:50
Entonces tengo que comprobar que en este momento 00:45:58
La aplicación que quiero instalar 00:46:02
Ocupa menos del espacio que tengo libre 00:46:05
¿Cómo lo hago? 00:46:10
¿Cómo no sabes el nombre? 00:46:12
Lee 00:46:22
Claro, la has guardado aquí 00:46:22
Por lo tanto, si nueva app.size es menor 00:46:25
Ay, ojalá tuviera yo un método para saber el espacio libre que tengo en el móvil 00:46:36
Esto se llama storage left 00:46:50
Si el tamaño que yo 00:46:56
O sea, si el espacio que me queda 00:47:01
Es mayor del tamaño 00:47:03
De esta nueva aplicación 00:47:05
Entonces puedo hacer lo que me dice aquí 00:47:07
Y lo voy a hacer 00:47:09
Si quiero puedo poner otro else aquí 00:47:12
Else 00:47:15
Si me da un else a este de aquí 00:47:16
O sea que esto es falso 00:47:19
Puedo decir 00:47:21
Error 00:47:23
no tienes 00:47:27
espacio suficiente 00:47:31
para 00:47:33
instalar 00:47:37
más 00:47:38
name 00:47:41
es el else 00:47:41
del 00:47:47
del if 00:47:48
que me dice si tengo espacio o no 00:47:50
bienvenido a la programación 00:47:53
este if me dice 00:47:57
así, de hecho 00:47:59
para si como este más de la cosa lo que puede hacer es pillar todo esto y llevármelo fuera 00:48:00
un método que haga esta cosa aquí de instalar efectivamente o ejecuta instalación de esta forma 00:48:06
todo esto desaparecería me quedaría aquí ejecuta instalación y se queda más limpio 00:48:14
dudas vamos a probarlo entonces voy a probar los métodos que he hecho ahora vale entonces 00:48:21
aquí yo tengo un móvil que he creado me da un listado de las aplicaciones pruebo a varias 00:48:36
cosas vale primero pruebo a instalar o sea get up la la aplicación gatito que me debería dar 00:48:45
Vamos a ver que me da 00:48:58
Error 00:49:03
No, se puede instalar la aplicación Gatito 00:49:07
Porque Gatito no está en el App Store 00:49:09
¿Vale? 00:49:13
Esto 00:49:16
Por ahora pinta bien 00:49:18
Vale, entonces intenta instalarme 00:49:21
Una de las que están 00:49:24
Fortnite 00:49:27
Fortnite 00:49:29
¿Vale? 00:49:33
app instalada correctamente 00:49:36
vale 00:49:41
si queremos para saber 00:49:43
que me ha instalado cuando dice 00:49:45
app instalada pues le digo 00:49:47
el nombre 00:49:49
name 00:49:50
instalada correctamente 00:49:52
vale 00:49:55
entonces ahora 00:49:56
fortnite instalada correctamente 00:49:58
perfecto 00:50:00
ahora lo que puedo hacer 00:50:04
es comprobar de 00:50:08
Instalar dos de ellas 00:50:10
¿Vale? Fijaos que Fortnite son 00:50:12
14, instalo también 00:50:14
TocToc, que me lo debería instalar 00:50:16
¿Vale? Entonces después 00:50:17
Instalo TocToc 00:50:19
Y me ha dado un error 00:50:21
Ah, le he puesto la mayúscula 00:50:32
La mayúscula 00:50:36
Ajá 00:50:39
Toc 00:50:41
Toc 00:50:44
Ahí 00:50:46
Muy quisquilloso 00:50:47
¡Vaya! He instalado correctamente 00:50:50
fenomenal y ahora para comprobar que efectivamente me la instalado vale a lo 00:50:52
mejor lo que puede decir es oye me las escribes la que tengo entonces por 00:51:00
ejemplo a raíz del punto dos string de vis a punto mi móvil apps 00:51:04
esto se enfada porque que no use andy's m1 m1 00:51:17
esto es simplemente ok quiero ver si me lo ha metido en dos espacios 00:51:31
¿Vale? Separados. 00:51:39
Vamos a ver si existe beta. 00:51:41
Ah, no, porque tengo que hacer un system. 00:51:49
Y esto va allí dentro. 00:51:51
Control X, control... Vale, ahora sí. 00:52:00
Venga. 00:52:03
¿Veis que está la primera aplicación, la segunda aplicación y luego un mogollón de nulo? 00:52:05
Que sí, está funcionando. 00:52:14
vale por ahora ahora intento instalar logs of legends que es 33 mi móvil no lo puede 00:52:16
gestionar logs of legends instalamos también logs of legends veamos si funciona lanzó error 00:52:22
no tienes espacio suficiente para instalar logs of legends mi móvil funciona fenomenal dudas 00:52:45
Espera un segundo que... 00:53:02
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
10
Fecha:
17 de enero de 2023 - 14:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
53′ 04″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
633.73 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid