Saltar navegación

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

Clase 29-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 29 de enero de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

En lo que nos apoyamos por debajo siempre es lo mismo. 00:00:00
Primero la programación estructural, por supuesto, 00:00:02
porque los métodos cuando hagan cositas, 00:00:04
lo harán con las estrategias de decisión, de bucles, etcétera. 00:00:07
Nos apoyamos en eso para los métodos. 00:00:10
Y luego nos apoyamos en cómo se declaran las clases, 00:00:14
cómo se crean objetos y cómo se pueden llamar a los métodos de objetos. 00:00:18
Y ya está, nos apoyamos sobre eso. 00:00:22
Pero sobre eso ya se hacen aplicaciones grandes 00:00:24
donde la dificultad es no perderse, ¿vale? 00:00:27
No perderse, esa es la dificultad. 00:00:29
Bueno, pues este era un ejemplito de eso, 00:00:31
como la que hicimos la de clientes y pedidos, pues esta de móviles. 00:00:34
Es un poco rara, pero la idea era cambiar de temática, 00:00:40
no estar siempre con alumnos, clientes, etcétera, ¿vale? 00:00:43
Cambiar un poco de temática. 00:00:47
Simular esa situación, ¿no? 00:00:49
De un móvil que tiene aplicaciones que puede instalar en un almacén y 00:00:52
luego aplicaciones instaladas, etcétera. 00:00:56
Vale, pues vamos a terminarla antes de seguir viendo cosas. 00:01:01
Bueno, recordad que el enunciado debía estar aquí en Descartes. 00:01:06
¿Verdad? 00:01:13
No, esto no era. 00:01:24
Esto era, ¿no? 00:01:38
El enunciado. 00:01:38
Vale, recordad que aquí la parte de diseño ya la teníamos 00:01:40
hecha, ya nos decían qué clases teníamos que hacer, 00:01:43
qué propiedades tenían que tener y qué métodos. 00:01:46
Esa parte de diseño ya estaba. 00:01:49
Pero no es el caso siempre. 00:01:53
A veces nos dirán, oye, necesito gestionar esto. 00:01:55
Y a partir de ahí ya uno decide qué clases representan esa situación y 00:02:00
qué debe hacer cada clase para gestionar las necesidades del que 00:02:05
nos lo ha pedido. 00:02:10
Aquí esa parte de diseño ya está. 00:02:11
Bueno, pues mejor. 00:02:13
Entonces, habíamos hecho, la parte que habíamos hecho era, 00:02:14
silencio. 00:02:20
A ver, Moisés y María, callaos. 00:02:28
Si queréis aprender a hablar por señas, pues hablad por señas. 00:02:33
Pero con algo que no haga ruido, ¿vale? 00:02:37
Porque si no, os cambio directamente. 00:02:42
Vale, a ver, entonces, las clases que habíamos hecho. 00:02:48
Habíamos hecho la entidad aplicación, 00:02:51
que representa a una posible aplicación, 00:02:55
una posible aplicación que se caracterizaba solo por su nombre, 00:02:57
su versión y su tamaño en gigas. 00:03:00
Ya está, una posible aplicación. 00:03:03
Entonces, por defecto, en una entidad siempre hacíamos 00:03:06
constructores con y sin parámetros, 00:03:11
getter y setter, porque las propiedades las hacemos 00:03:17
privadas y accedemos a ellas desde fuera de la clase con los 00:03:20
get para leer y con los set para escribir. 00:03:24
Y luego simplemente un método, simplemente un método que 00:03:27
simulaba que la aplicación se estaba ejecutando, nada más. 00:03:30
Simulaba que esa aplicación se estaba ejecutando, 00:03:33
nada más que eso. 00:03:36
Entonces, ese método no es estático, 00:03:38
porque ese método simula que es una aplicación concreto la que 00:03:41
se ejecuta, una. 00:03:45
Entonces, el método depende de esa aplicación y, por tanto, 00:03:47
no tiene sentido que sea estático. 00:03:50
Por eso incluíamos aquí nombre, para forzar a que no fuera 00:03:52
estático, ¿verdad? 00:03:57
Desde el momento en que depende de una propiedad de la clase, 00:03:58
ya es imposible que lo sea. 00:04:01
Bueno, pues nada, ese método no es tontería para simular que 00:04:02
una aplicación se está ejecutando. 00:04:06
Nada más que eso, ¿vale? 00:04:08
Y luego teníamos el almacén de aplicaciones. 00:04:11
El almacén de aplicaciones tenía un conjunto de aplicaciones de 00:04:14
esas anteriores, un conjunto de esas, ¿vale? 00:04:18
Un conjunto de esas aplicaciones. 00:04:23
Entonces, un conjunto de esas aplicaciones tiene que ser una 00:04:24
estructura de datos que represente mucho de algo que 00:04:27
ahora mismo solo conocemos el array. 00:04:31
Pues ya está, un array, muchas de esas. 00:04:34
Con sus constructores, su get, su set. 00:04:37
Y el constructor nos dijeron, a ver, 00:04:49
haz un constructor que en lugar de recibir el array como tal, 00:04:52
reciba una cadena. 00:04:56
Reciba una cadena que contenga todos los datos de las 00:04:57
aplicaciones, ¿verdad? 00:05:00
Recibía una cadena de este estilo. 00:05:02
Recibía una cadena. 00:05:04
Y dentro de esa cadena estaban los datos de todas las 00:05:05
aplicaciones con las que íbamos a construir ese almacén. 00:05:10
Bueno, pues, entonces, en este constructor tuvimos que 00:05:14
indagar, averiguar métodos de la clase string que nos 00:05:19
facilitaran la tarea de romper en cachitos este string y con 00:05:23
cada cachito instanciar un objeto aplicación, 00:05:29
meterlo en el array, etcétera, ¿vale? 00:05:32
Bueno, pues, para eso descubrimos que teníamos un 00:05:35
método split que nos era muy útil para romper un string en 00:05:38
trocitos separados por un separador, 00:05:42
el separador que uno le quisiera dar, este aquí, 00:05:45
luego este, etcétera. 00:05:48
Y de esa manera instanciábamos una aplicación y la guardábamos 00:05:50
en el almacén. 00:05:53
Entonces, nuestro constructor era un constructor hecho a medida 00:05:55
de lo que nos habían pedido. 00:06:00
Un constructor que recibió una cadena y rellenaba el array de 00:06:02
arriba, rellenaba el array de arriba con las aplicaciones 00:06:06
cuya información estaba recogida en esa cadena. 00:06:12
Ya está, un constructor, pues, bueno, raro. 00:06:14
Y luego ya esta aplicación nos dijeron, bueno, 00:06:17
hazle más métodos. 00:06:20
Hazle el método install, install. 00:06:21
Este método recibía un nombre de aplicación, 00:06:26
recibía un nombre, por eso recibía un string, 00:06:28
y buscaban el almacén de arriba, 00:06:31
buscaban el almacén, la aplicación cuyo nombre fuera 00:06:33
igual. 00:06:36
Y una vez que la encontraba, creaba un objeto distinto, 00:06:37
pero cuyas propiedades eran idénticas de este, ¿vale? 00:06:43
O sea, creaba un objeto diferente apuntado por la 00:06:47
dirección a, ¿verdad? 00:06:51
Creaba un objeto distinto. 00:06:52
Desde el momento en que se hace un new, 00:06:54
el new significa aparece un espacio para un objeto en 00:06:55
memoria. 00:06:59
Eso significa el new, aparece un espacio nuevo. 00:07:00
Ese espacio tiene que estar apuntado por algún sitio. 00:07:03
¿Por dónde está apuntado? 00:07:06
Pues, allá donde asignemos el resultado del new, ¿verdad? 00:07:07
Así funciona esto. 00:07:11
El new significa crea espacio para un objeto de esta clase 00:07:13
y la dirección devuélvemela y guárdala en la referencia que 00:07:18
yo ponga aquí. 00:07:21
Eso es como funciona, ¿no? 00:07:23
La instanciación de un objeto. 00:07:24
Bueno, pues, efectivamente hacíamos un objeto nuevo, 00:07:26
un espacio de memoria nuevo, pero para que fuera una copia 00:07:29
del otro, copiábamos las propiedades. 00:07:32
Las propiedades del objeto que habíamos creado apuntado por a, 00:07:35
pues, las copiábamos de las del almacén. 00:07:39
Entonces, hacíamos una copia, dos objetos distintos, 00:07:43
pero con las mismas propiedades, pero objetos distintos. 00:07:47
Entonces, eso es lo que se llama hacer un clon, en realidad. 00:07:51
Entonces, tú haces un clon y desde el momento en que son 00:07:54
dos objetos distintos, lógicamente, 00:07:56
cuando tú cambies los datos de uno, 00:07:59
las del otro no se van a cambiar porque son dos objetos distintos. 00:08:02
Son dos objetos diferentes. 00:08:05
Aquí lo que dijimos es, sin embargo, 00:08:09
si hacíamos esto, declarábamos una referencia a, 00:08:11
declaramos una referencia y a esa referencia le dábamos la 00:08:15
referencia esta, ahí no había dos objetos distintos. 00:08:18
Ahí había un único objeto apuntado por dos variables distintas, 00:08:22
por la variable a y por esta variable. 00:08:29
Pero era un único objeto, un único objeto apuntado por dos 00:08:32
referencias, por a y por esta. 00:08:36
Entonces, ahí como hay un único objeto, 00:08:38
me da igual acceder a ese objeto a partir de aquí que a partir de aquí, 00:08:40
porque estoy haciendo el mismo. 00:08:43
Si cambio las propiedades del objeto apuntado por este, 00:08:44
estoy cambiando también las propiedades del objeto apuntado por este, 00:08:47
porque están apuntando al mismo. 00:08:51
Entonces, lógicamente, el funcionamiento de esto y el 00:08:53
funcionamiento de esto es completamente distinto, ¿vale? 00:08:56
Aquí hay dos direcciones que llevan al mismo objeto y aquí hay dos 00:08:59
direcciones que llevan a distintos objetos, ¿vale? 00:09:04
Bueno, es importante entender eso. 00:09:09
¿En qué situaciones? 00:09:13
En una aplicación necesita trabajar con copias, 00:09:14
necesita trabajar con el mismo objeto porque tiene efectos distintos, 00:09:17
bueno, pues, el método de instalo hacía eso. 00:09:21
Sacaba una copia, un objeto copia y lo devolvía como valor de retorno, 00:09:23
lo devolvía ahí, ¿vale? 00:09:27
Ala, ya está. 00:09:30
Y luego había otro método que decía también para este almacén de 00:09:31
aplicaciones, silencio, había otro método para ese almacén de 00:09:35
aplicaciones que te decía, yo te doy un objeto app y mételo en el 00:09:44
array. 00:09:48
Pues, esto sí que es la historia de siempre, 00:09:49
la historia de toda la vida, ¿vale? 00:09:52
Mételo en el array. 00:09:53
Pues, ala, ahí metido, se acabó. 00:09:54
Entonces, bueno, este main lo hicimos aquí para probar lo del 00:09:56
split, a ver si nos había funcionado, ¿vale? 00:10:02
Y también, también lo hice ahí para que entendierais que un main 00:10:06
en realidad es un método que uno puede poner en cualquier lado 00:10:10
porque es un método más. 00:10:13
Un main es un método más, un método más que uno pone en la 00:10:14
clase que quiera. 00:10:18
Pero, claro, si uno pone en una clase un método main, ¿qué ocurre? 00:10:19
Que automáticamente esa clase se convierte en punto de arranque de 00:10:22
una aplicación porque eso es el método main. 00:10:27
El método main es el punto de arranque de una aplicación. 00:10:29
Cuando a una máquina virtual la llamamos para que ejecute una 00:10:32
aplicación, ella busca el main. 00:10:36
Entonces, aquí pusimos un main para poder ejecutar esa clase, 00:10:39
para poder ejecutarla y probar esto. 00:10:42
Y esta clase en particular lo que hacía era instanciar este 00:10:45
objeto, llamar al constructor para ver si el constructor hacía 00:10:48
lo que queríamos nosotros, que era, pues, 00:10:52
hacer el split del patatín. 00:10:56
Y comprobamos que sí que lo hacía, 00:10:58
que eso estaba bien hecho, etcétera. 00:10:59
Entonces, este main aquí ahora mismo, pues, bueno, 00:11:01
nos vino muy bien para hacer las pruebas, 00:11:05
pero podemos dejarlo comentado para no liar porque luego esta 00:11:06
aplicación ya tendrá su main aparte en otra clase, 00:11:15
en otra clase en la que cree el almacén, 00:11:18
cree las aplicaciones, etcétera. 00:11:20
Bueno, pues, ya teníamos estas 2 clases hechas, 00:11:22
una única aplicación y un almacén. 00:11:25
Bueno, y nos faltaban, ¿no? 00:11:30
Nos faltaban métodos. 00:11:31
Habíamos hecho el de App Store, habíamos hecho el install, 00:11:32
el incorporar, que me lo inventé yo, pues, 00:11:35
para meter una aplicación, cambiar versión, 00:11:38
prestar aplicaciones y comprobar actualización, ¿vale? 00:11:41
Moisés, por fa, siéntate aquí delante. 00:11:47
Y Andrés, tú ponte ahí, en ese hueco que hay ahí, estupendo. 00:11:54
Vale, estos 3 métodos nos faltan de App Store. 00:12:03
Luego nos falta la clase móvil, que representa a un móvil. 00:12:08
Y luego ya nos falta el main. 00:12:13
Este es el main para hacer las pruebas, ¿vale? 00:12:15
Ya está. 00:12:17
Venga, pues, vamos con cambiar versión. 00:12:24
Parece la más sencilla. 00:12:27
Vamos a ver. 00:12:29
Venga, a ver, cambiar versión. 00:12:33
Sí, incorporar, este era, por si, 00:12:39
se supone que el almacén de aplicaciones se crea con el 00:12:45
constructor a partir de la cadena y se crea. 00:12:48
Entonces, yo había metido ese método por si a posteriori, 00:12:52
una vez que el objeto App Store está creado, 00:12:55
por si quisieras meter otra más. 00:12:57
Si quieres meter otra más, pues, necesitas un método para meterlo. 00:12:59
Vale. 00:13:08
Vale. 00:13:14
Venga, sí que tardas tú. 00:13:15
Bueno, a ver, estábamos con el método este, cambiar versión. 00:13:21
Vale, cambiar versión. 00:13:29
Si se va a llamar desde fuera, que es la idea, 00:13:30
porque esta es la funcionalidad que ofrece App Store hacia el 00:13:39
exterior. 00:13:42
La clase App Store ofrece una funcionalidad al exterior de 00:13:43
cambiar versiones. 00:13:47
Venga, ahí, por ejemplo. 00:13:50
Cambiar versiones, incorporar apps, lo que sea. 00:13:52
Entonces, las ofrece al exterior. 00:13:56
Entonces, el método es público. 00:13:58
Y ahora ya, pues, cambiar versión, 00:14:02
el nombre nos lo han hecho, pues, no lo podemos elegir. 00:14:04
Y dice, este método recibe como parámetros una cadena y un 00:14:14
entero. 00:14:20
Una cadena, que se supone que es el nombre de una aplicación, 00:14:20
y un entero, que se supone que es una versión. 00:14:31
¿Vale? 00:14:38
¿Qué tiene que hacer? 00:14:38
Pues, entonces, cambia la versión de la aplicación dentro 00:14:40
del almacén de la RAI, que se llame así, la cambia a esta. 00:14:47
¿Vale? 00:14:55
Cambia la versión de la aplicación, 00:14:55
que se llame así, la cambia a esta. 00:14:57
Entonces, pregunta, ¿qué hago yo? 00:15:00
¿Qué pongo aquí? 00:15:05
Dictadme, ¿qué pongo? 00:15:08
Void, sí. 00:15:13
¿Vale? 00:15:14
Pongo void. 00:15:14
Porque este método, el efecto que tiene, 00:15:15
el efecto que tiene simplemente es sobre la propiedad de la 00:15:17
clase. 00:15:21
Recordad que estamos en esta clase cuya propiedad es esta. 00:15:22
¿Vale? 00:15:25
Tiene este efecto. 00:15:25
¿Vale? 00:15:27
Bueno, pues, entonces, no tiene que devolver nada. 00:15:28
Otra cosa es que me dijeran, oye, 00:15:30
que devuelva un boolean, que hay veces es un método habitual, 00:15:32
que sea true o false, si lo pudo hacer o no lo pudo hacer. 00:15:35
Hay veces que cuando un método no hace falta que devuelva 00:15:40
nada, lo que se le hace es que devuelva un boolean que te 00:15:43
sirva como control. 00:15:47
Si lo ha podido hacer correctamente, te devuelve true. 00:15:48
Si no lo ha podido hacer correctamente, te devuelve false. 00:15:51
Pero, claro, eso sobre todo tiene utilidad si lo que hace el 00:15:53
método implica llamar a cosas raras, 00:15:55
conectarse a una base de datos. 00:15:58
Porque ahí, que lo haga bien o mal, 00:15:59
va a depender de cosas que se escapan a tu control. 00:16:00
Aquí este método, lo único que hace es acceder a un array que 00:16:04
está dentro de la clase, que va a funcionar mal. 00:16:07
No hay nada que pueda funcionar mal. 00:16:10
Entonces, no tiene sentido incorporar un boolean de 00:16:11
control, ¿vale? 00:16:14
Pero es un patrón, es un patrón de programar que se usa mucho. 00:16:15
Devolver un boolean de control que te diga si se ha hecho bien 00:16:22
o mal. 00:16:24
Pero nosotros por ahora ni lo incorporamos. 00:16:25
Vale, pues, venga. 00:16:28
Cambiar versión. 00:16:30
Ala, pues, venga. 00:16:31
Vale, pues, nada. 00:16:37
Nosotros este método changeVersion, 00:16:38
¿quién lo va a llamar? 00:16:40
Lo va a llamar un objeto de esta clase, 00:16:42
un objeto de esta clase porque ese método está en esa clase, 00:16:45
obviamente. 00:16:48
Y lo va a llamar teniendo dentro su almacén de aplicaciones, 00:16:49
claro, obviamente, porque esa es una propiedad de la clase. 00:16:53
Vale, pues, entonces, ¿qué tendrá que hacer este método? 00:16:56
Buscar en ese array la aplicación que se llame así. 00:16:58
Y a la que se llame así cambia la versión, ¿verdad? 00:17:02
Es lo que tiene que hacer. 00:17:05
Bueno, pues, buscar en el array, pues, 00:17:06
ya sabemos de toda la vida. 00:17:08
Vamos a buscar en el array. 00:17:10
Siempre vamos a buscar en ese array que se llama apps, 00:17:13
creo que se llamaba, ¿no? 00:17:18
Igual no se llama así porque no me está ofreciendo nada. 00:17:20
Se llama store. 00:17:24
Vale. 00:17:25
En ese array que se llama así vamos a buscar la aplicación 00:17:28
cuyo nombre sea igual que este. 00:17:35
Es recorrer un array que hemos recorrido toda la vida. 00:17:37
Y en ese array, ¿qué queremos hacer? 00:17:40
Pues, vamos a aplicación por aplicación dentro de ese array. 00:17:43
Aplicación por aplicación. 00:17:46
Oye, si esta aplicación en la que estoy resulta que su nombre, 00:17:48
el nombre lo sacó con get, claro, 00:17:54
que su nombre es igual que el de búsqueda que me han dado. 00:17:56
Ah, vale, pues, ya estoy. 00:18:02
Esta es la aplicación de la cual quiero cambiar la versión. 00:18:03
Es esta, ya la he encontrado. 00:18:06
Es la búsqueda del array de siempre. 00:18:08
Y en cada posición miro a ver si cumple la condición de 00:18:10
búsqueda. 00:18:13
¿Es igual que el nombre? 00:18:14
Sí. 00:18:15
Ah, justo, ya la encontré. 00:18:15
Ahora, ¿qué hago con ella una vez encontrada? 00:18:17
Cambiarle la versión. 00:18:19
Pues, a la, le cambio la versión. 00:18:20
¿A cuál? 00:18:28
A la que me han dado como parámetro y listo. 00:18:29
¿Vale? 00:18:30
Y ya está, ya acaba el método. 00:18:31
No había falta buscarlo también por la versión. 00:18:33
No, el método te dice, la aplicación que se llame así, 00:18:38
a esa le pones como nueva versión la que yo te he dado, 00:18:42
sobreescribiendo la otra. 00:18:46
Entonces, tu parámetro de búsqueda es el nombre. 00:18:47
Por ese es por el que buscas. 00:18:49
Este es el parámetro por el que buscas. 00:18:51
Entonces, cuando has encontrado la aplicación cuyo nombre es 00:18:54
ese, ya la tienes. 00:18:57
Tu búsqueda ya ha terminado. 00:18:59
Vale, ¿ahora qué haces con esa aplicación? 00:19:00
Lo que te han dicho que hagas, que en este caso es, 00:19:03
ponerle como versión la que te estoy dando, 00:19:06
pisando la que tuviera de antes, claro. 00:19:08
¿Vale? 00:19:11
Bueno, pues ya está, este método ya estaría. 00:19:13
A ver, aquí pasa lo de siempre, que imaginaos que el almacén de 00:19:16
aplicaciones tiene 50,000, yo qué sé, 50,000. 00:19:21
Entonces, y la encuentra a la primera, 00:19:27
a la primera la ha encontrado. 00:19:29
Pues, hombre, se está 49,999 iteraciones que ya le sobran, 00:19:31
¿vale? 00:19:36
Porque ya la ha encontrado, que ya le sobran. 00:19:37
Entonces, hombre, no estaría mal si hacemos una forma de que, 00:19:39
para que este bucle pare, para que este for deje de ejecutarse 00:19:43
una vez que este if ya se cumplió, ¿verdad? 00:19:47
Que no pasa nada, lo podemos dejar así, no ocurre nada. 00:19:52
Pero, bueno, si lo dejamos de ejecutar una vez que hemos 00:19:55
encontrado la aplicación. 00:19:58
Entonces, aquí viene la discusión de siempre. 00:20:00
Aquí viene la discusión de siempre. 00:20:03
Sí, el método feo o el método bonito, ¿vale? 00:20:05
Esa es la discusión de siempre. 00:20:16
¿Cuál es el método feo? 00:20:23
Para hacer eso que digo, una vez que hemos encontrado la 00:20:27
aplicación que se llama así y, por tanto, 00:20:31
ha entrado en el if, ¿cómo conseguimos que el bucle ya no 00:20:34
se ejecute más veces? 00:20:37
Que sea esta la última y poder. 00:20:39
El método feo es el break, efectivamente. 00:20:40
Entonces, este es el método feo, ¿vale? 00:20:43
Pues, ya está, el método feo salió, ¿vale? 00:20:47
O sea, aquí estamos hablando de un bucle for que tiene una 00:20:50
línea. 00:20:53
Entonces, hombre, el que vea este código, pues, hombre, 00:20:54
más o menos va a entender. 00:20:57
Pero recordad que, porque es feo el break y porque en algunos 00:20:59
lenguajes de programación, de hecho, 00:21:02
está incluso prohibida como sentencia eliminada, 00:21:04
porque dificulta la legibilidad del código. 00:21:07
Break no significa nada, break en sí mismo no tiene 00:21:12
información. 00:21:14
No te da la razón de por qué has parado, no te la da. 00:21:15
Y eso es feo, no te la está diciendo. 00:21:19
Entonces, nosotros aquí lo vemos porque el break está 00:21:22
pegadito al if, está juntito. 00:21:25
Entonces, lo vemos, ah, vale, va a salir porque ya lo encontró. 00:21:28
Entonces, queremos salir cuando lo encuentre. 00:21:31
Pero es que está muy pegadito, la razón por la que salimos y 00:21:33
el break están juntos. 00:21:36
Entonces, ahí la legibilidad, bueno, más o menos se ve. 00:21:37
Pero en otras situaciones, tú ves ahí un break plantado y 00:21:40
tienes que irte 300 líneas más arriba para entender por qué le 00:21:43
ha dado la gana salir. 00:21:48
Y esa no es la idea. 00:21:49
Eso hace que el código no sea nada legible. 00:21:50
Si no es legible, es difícilmente modificable. 00:21:52
Y un código que no es actualizable o modificable, 00:21:56
se queda sin tiempo de vida. 00:21:59
Su tiempo de vida se desaparece. 00:22:00
Entonces, no vale para nada. 00:22:05
Entonces, por eso es una sentencia fea, 00:22:07
desagradable a la vista. 00:22:09
Lo normal es salir de un for incorporándolo aquí arriba en 00:22:12
la condición. 00:22:16
Y decir, yo no he llegado al final. 00:22:17
O no he encontrado no sé qué. 00:22:21
Y para eso, pues, hacemos un boolean que se ha encontrado, 00:22:23
que lo cambiemos aquí. 00:22:26
Pongamos, no he encontrado aplicación. 00:22:27
Eso es más bonito. 00:22:31
Eso sería más bonito. 00:22:33
Algo así. 00:22:37
App encontrada. 00:22:47
Inicialmente es falso. 00:22:52
No está encontrada. 00:22:53
Y ahora, cuando ya la hemos encontrado, 00:22:55
voy a dejar aquí el break, no borrado, pero comentado. 00:22:57
Cuando ya la hemos encontrado, avisamos, 00:23:01
app encontrada igual a true. 00:23:03
Ya la hemos encontrado. 00:23:09
Está encontrada. 00:23:10
Fenomenal. 00:23:11
Esta es la estructura nuestra de toda la vida, ¿no? 00:23:11
Con la que tenemos que familiarizarnos. 00:23:14
Yo hago un recorrido para buscar algo. 00:23:17
De partida asumo que no está. 00:23:19
Cuando lo he encontrado, ya puedo cambiar la conclusión. 00:23:21
Ya puedo cambiarla. 00:23:24
Y ahora esto lo usamos para muchas cosas. 00:23:25
Lo podemos usar aquí fuera para distinguir si la hemos 00:23:29
encontrado o no, mostrándolo por consola si es que no lo piden. 00:23:32
La podemos usar aquí dentro para forzar que el bucle ya no se 00:23:35
ejecute más. 00:23:39
Podremos usar este boolean para muchas cosas. 00:23:39
Entonces, en particular, podemos usarlo para incorporarlo y 00:23:43
hacer esta condición de aquí un poquito más grandecita. 00:23:46
Y decir, este bucle se va a ejecutar mientras yo no haya 00:23:49
llegado al final y la aplicación no esté encontrada. 00:23:54
A ver si lo, vamos a revisarlo, porque igual lo he escrito mal. 00:24:03
Mientras yo no haya llegado al final y no haya encontrado la 00:24:09
aplicación, entonces sigue. 00:24:13
Es decir, para que el bucle siga, 00:24:17
tienen que darse simultáneamente dos cosas. 00:24:19
Tienen que darse simultáneamente. 00:24:22
No haber terminado con el array, por supuesto, 00:24:24
pero no haber encontrado la aplicación. 00:24:27
Tiene que ser la simultaneidad de dos cosas para que el bucle 00:24:30
siga. 00:24:34
La simultaneidad de dos cosas es el AND. 00:24:34
¿Vale? 00:24:37
¿Si no tiene falta la condición del true? 00:24:37
¿Perdón? 00:24:42
Si sigue, tiene falta el true. 00:24:43
Después de poner el AND. 00:24:46
Esto dices. 00:24:47
Bueno, claro, porque si no, esta condición nunca va a cambiar. 00:24:48
Es decir, con esto yo ya digo, ah, ya la he encontrado. 00:24:52
Y eso va a hacer que el bucle ya deje de ejecutarse. 00:24:55
Es que si yo no pongo esto a true, 00:25:00
esta condición va a ser true toda la vida. 00:25:01
Nunca va a ser falsa. 00:25:04
Este bucle se va a dejar de ejecutar cuando una de las dos 00:25:06
sea falsa, ¿no? 00:25:08
Esta está clara porque ya he terminado. 00:25:10
O sea, el vale es que ya las he entendido. 00:25:13
Ah, vale, vale. 00:25:15
Vale, pues, entonces, cambiar versión, ya está. 00:25:20
Vale. 00:25:24
Listar aplicaciones. 00:25:28
Bueno, esta parece más sencilla. 00:25:29
Bueno, un string que en una única cadena contenga el listado 00:25:31
de todas las apps y su tamaño. 00:25:36
Pues, venga, vamos a hacer listar aplicaciones. 00:25:39
Devuelve un string. 00:25:43
Pública otra vez. 00:25:51
Devuelve, esta sí que devuelve como valor de retorno, 00:25:58
devuelve un string como valor de retorno. 00:26:01
Lo voy a poner ahí. 00:26:03
Vale. 00:26:11
Ala, listado de aplicaciones. 00:26:15
Tiene que construir un string. 00:26:18
Este va a ser mi resultado, ¿verdad? 00:26:21
Tiene que construir un string ahí. 00:26:23
Tiene que construirlo y al final acabar devolviéndolo. 00:26:32
Vale, ¿cómo lo va a construir? 00:26:45
Concatenando sobre él los datos de las aplicaciones que hay 00:26:47
aquí. 00:26:50
Por eso no se le pasa nada como parámetro. 00:26:51
Por eso no se le pasa nada. 00:26:54
Porque todos los datos que necesita para trabajar, 00:26:55
todos los que necesita, están aquí arriba. 00:26:58
Directamente en una propiedad de la clase. 00:27:01
Por eso no se le pasa nada. 00:27:04
No necesita nada. 00:27:05
Bueno, pues, venga, este método. 00:27:07
Lo mismo, a hacerlo en un ratín. 00:27:10
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
29 de enero de 2024 - 17:52
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
27′ 14″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
119.75 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid