Saltar navegación

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

Clase 26-01-24 - 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 28 de enero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Vale? 00:00:00
Entonces, el objetivo de este constructor, por tanto, 00:00:03
como casi todos los constructores, 00:00:05
es recibir datos y con esos datos inicializar las propiedades 00:00:07
de la clase. 00:00:12
Las propiedades de la clase en este caso es un array. 00:00:14
Pues, entonces, tiene que recibir datos para inicializar 00:00:16
ese array. 00:00:19
¿Vale? 00:00:20
¿Qué datos recibe el constructor? 00:00:21
Recibe una cadena. 00:00:23
Esta, por ejemplo. 00:00:26
Esta. 00:00:28
Y ahora, el problema es que como recibe los datos en una única 00:00:30
cadena, los tengo yo que sacar para inicializar ese array. 00:00:32
Bueno, pues, es lo que hemos hecho. 00:00:36
Hemos sacado de esa cadena, hemos sacado los datos 00:00:39
separados por punto y coma. 00:00:46
Cada dato es una app. 00:00:48
Pues, ahora ya me creo el store, que es el array de apps con el 00:00:50
mismo tamaño que los datos que yo he sacado de mi cadena, 00:00:53
el mismo tamaño. 00:00:56
Y ahora ya recorro cada una de las subcadenas que son cada app, 00:00:58
las recorro, saco de ellas los 3 datos, 00:01:02
saco de ellas los 3 datos. 00:01:07
Y ya que tengo los 3 datos, instancio el objeto y a la 00:01:10
posición del almacén correspondiente, 00:01:12
a la posición correspondiente. 00:01:14
Bueno, pues, ya ha hecho el constructor. 00:01:16
Ya ha hecho el constructor que crea un almacén de aplicaciones 00:01:18
con las aplicaciones que yo le doy. 00:01:21
Nombre, versión y tamaño. 00:01:23
Vale. 00:01:25
Bueno, pues, ya tenemos el constructor del almacén de 00:01:26
aplicaciones que está en el móvil, se supone. 00:01:31
El almacén de aplicaciones. 00:01:34
Bueno, pues, venga, ¿qué más cosas hay que hacer en esta 00:01:36
clase? 00:01:40
Pues, lo que me diga el enunciado, 00:01:41
porque el enunciado ya ha hecho un diseño, ya lo ha hecho. 00:01:42
Pues, yo lo respeto. 00:01:45
Vale, ya hemos hecho. 00:01:48
Bueno, el constructor ya está. 00:01:49
Y ahora tiene más métodos. 00:01:52
Tiene todos estos. 00:01:55
Tiene install, change version, lista de aplicaciones y check 00:01:57
update. 00:02:00
Tiene todo eso. 00:02:02
¿Vale? 00:02:03
Pues, hay que hacer esos 4 métodos. 00:02:04
Vale. 00:02:08
Vamos a hacer el primer método. 00:02:09
Install. 00:02:11
Install dice que recibe el nombre de una aplicación y 00:02:12
devuelve una copia del objeto A que está en ese almacén 00:02:18
correspondiente. 00:02:23
A ver, la idea de esto es, el teléfono, el terminal, 00:02:26
el teléfono, tiene ahí todas las aplicaciones que puede usar. 00:02:29
Todas las que puede usar. 00:02:35
Pero son similares en todas instaladas. 00:02:37
Son las que puede usar. 00:02:39
Entonces, cuando le damos a instalar a una de ellas a 00:02:40
través de este método, cuando le damos a instalar, 00:02:43
coge una y la instala, pero hace una copia. 00:02:45
Entonces, la que se instala y luego se ejecutará es una 00:02:49
copia. 00:02:51
¿Vale? 00:02:52
Y el almacén tiene sus propias aplicaciones, 00:02:53
tiene las aplicaciones. 00:02:55
Pero hace una copia, hace una copia del objeto aplicación, 00:02:58
hace una copia y esa es la que se queda instalada y 00:03:02
ejecutada. 00:03:05
De ahí lo de devuelve una copia. 00:03:06
Vale, vamos a intentar entender esto bien. 00:03:09
Venga, pues, vamos a hacer el método de instalar. 00:03:12
Que tiene solo una línea o prácticamente, 00:03:15
pero luego tiene su gracia entenderlo, que es la idea. 00:03:18
Pues, venga, método install de la aplicación esta. 00:03:21
Este es el auxiliar, lo dejo ahí abajo por si acaso lo uso. 00:03:26
El método install sí que se va a usar desde fuera, entonces. 00:03:30
Dice, ¿qué dice? 00:03:34
Devuelve una copia de la aplicación cuyo nombre se ha 00:03:37
pasado por parámetro, porque se ha pasado un string. 00:03:42
Pues, venga, install. 00:03:46
Entonces, el valor de retorno se queda aquí. 00:03:49
El método install recibe un nombrecito, nombre app. 00:03:54
Y se supone que con este nombre que recibe, 00:04:03
buscará en el almacén que está aquí arriba, 00:04:07
buscará el almacén. 00:04:10
Por eso no hay que pasárselo al método. 00:04:11
Buscará el almacén y devolverá una copia de la aplicación que 00:04:14
tenga ese nombre. 00:04:18
Luego, el valor de retorno de este método, ¿cuál será? 00:04:19
Que tengo que poner ahí. 00:04:22
Exactamente, app, ¿vale? 00:04:25
Porque va a devolver un objeto a aplicación. 00:04:28
Entonces, uno podría, a lo mejor, plantearse hacer esto. 00:04:32
Vamos a buscar la aplicación que se llama así en todo el 00:04:40
array. 00:04:42
Vamos a recorrer el array. 00:04:46
Vamos a recorrerlo y comparamos nombres. 00:04:56
Si store de i, que es la aplicación que está en la 00:05:00
posición i del almacén, su nombre resulta que es igual al 00:05:04
nombrecito que me han pasado, uno podría decir, ah, 00:05:14
ya la he encontrado. 00:05:19
Y podría decir, pues, venga, devuelvo esa aplicación. 00:05:20
¿Vale? 00:05:32
Bueno, ahora voy haciendo preguntas. 00:05:34
Primero, digo lo que he escrito. 00:05:41
Tengo el almacén de objetos app, que es una propiedad de la 00:05:44
clase en la que estoy, el almacén de objetos app. 00:05:47
Lo recorro para cada aplicación que está en ese array. 00:05:49
Si su nombre es igual al que me han pasado, 00:05:53
devuelvo esa aplicación enterita. 00:05:56
Devuelvo esa aplicación enterita. 00:05:59
Bueno, eso es lo que yo he escrito ahí. 00:06:01
Vale, primera pregunta, ¿qué hago? 00:06:05
¿Por qué el compilador me lo marca en rojo? 00:06:08
No lo miréis y me lo leáis. 00:06:10
¿Por qué creéis que el compilador me marca en rojo un 00:06:14
error de compilación ahí? 00:06:17
No, al fin y al cabo, el tipo de dato está bien. 00:06:19
Bueno, lo que creáis. 00:06:21
¿Con qué creéis que está relacionado que el compilador 00:06:32
me ponga eso rojo? 00:06:34
Vale, vamos dando pistas. 00:06:44
El método tiene que devolver un objeto app sí o sí. 00:06:47
Eso está claro, ¿no? 00:06:49
Porque yo he puesto aquí app, tiene que devolver un objeto 00:06:51
app sí o sí. 00:06:53
Eso está claro. 00:06:54
Vale. 00:06:55
¿Este método va a devolver un objeto app sí o sí? 00:06:57
No. 00:07:05
Explícate más. 00:07:07
Explícate más. 00:07:13
Sí, la respuesta es no, efectivamente. 00:07:14
O sea, la respuesta es no siempre. 00:07:23
A ver, devolverá un objeto app si esto es true alguna vez. 00:07:26
Pero imaginaos que no hay ninguna aplicación en almacén 00:07:32
cuyo nombre sea igual que este, que no hay ninguna. 00:07:35
Entonces, jamás entra en el if, saldría del for, por aquí, 00:07:37
saldría y nunca jamás habría entrado aquí. 00:07:41
Pues es lo que dice el compilador. 00:07:45
Te dice, oye, perdona, que hay alguna aplicación aquí cuyo 00:07:46
nombre coincide. 00:07:50
Genial, no te digo nada, no te pongo pegas. 00:07:51
Vas a devolverme el objeto app. 00:07:53
Pero te dice, oye, ¿qué pasa si el for ha terminado con lo 00:07:55
cual he saltado este punto y yo jamás entré en el if? 00:08:00
Te dice, entonces, ¿qué? 00:08:03
Me tienes que devolver un app sí o sí. 00:08:04
Claro, siempre tiene que devolver, si yo aquí pongo app, 00:08:07
siempre tiene que devolver un objeto app, siempre. 00:08:09
Pase lo que pase. 00:08:13
Y con lo que yo he escrito, si este if nunca es true, 00:08:15
el for terminaría, seguiríamos por aquí y ahí no hay ningún 00:08:20
retún que devuelva nada. 00:08:23
Entonces, es lo que me dice el compilador, me dice, oye, 00:08:25
siempre pase lo que pase, se cumple la condición alguna vez, 00:08:28
no se cumple nunca. 00:08:31
Siempre tienes que devolver un objeto app, ¿vale? 00:08:32
Entendéis por qué lo pone rojo, ¿no? 00:08:37
Bueno, pues, entonces, yo, si he llegado a este punto sin haber 00:08:41
salido aquí por el retún, si he llegado a este punto, 00:08:50
es porque esto nunca fue true. 00:08:53
Pues, tengo que darle algo, tengo que darle algo para que 00:08:55
se calle. 00:08:57
Tengo que darle un objeto app, algo. 00:08:57
¿Qué sería natural devolverle ahí? 00:09:00
¿Un retún tengo que hacerle? 00:09:01
INTERLOCUTOR 1. 00:09:02
Haces que primero retún y esto sea un null y luego devuelves. 00:09:03
INTERLOCUTOR 2. 00:09:06
Ah, no, esto no lo puedo tocar, esto tiene los apps. 00:09:07
A ver, no os compliquéis la vida. 00:09:09
Le digo, pues, si no hay ninguna, ¿yo qué te voy a hacer, 00:09:11
hijo mío? 00:09:14
Le digo, es que no he encontrado ninguna que se llame así, 00:09:15
pues, te devuelvo una app null, ya está, ¿no? 00:09:18
Entonces, este método, recorre el almacén, va uno por uno. 00:09:26
¿Que tiene la suerte de encontrar una aplicación cuyo 00:09:31
nombre sea igual a nombre? 00:09:34
Genial. 00:09:36
La devuelve, lo de la copia y todo eso, 00:09:36
ahora ya nos metemos, devuelve esa aplicación y todo termina, 00:09:39
se acabó. 00:09:42
¿Que no ha tenido la suerte, no ha tenido la suerte de 00:09:44
encontrar una aplicación cuyo nombre sea igual al que me han 00:09:47
pasado? 00:09:49
El for ha acabado y el método sigue, el método sigue. 00:09:50
¿Qué hace? 00:09:54
Le digo, pues, chico, no tengo nada que devolverte, 00:09:55
no tengo nada que devolverte, pero un objeto hay que 00:09:57
devolver, un objeto hay que devolver sí o sí, 00:09:59
porque yo me he comprometido poniendo ahí app. 00:10:01
Pues, te devuelvo null, ¿qué te voy a devolver? 00:10:03
No voy a inventar una app cualquiera, 00:10:05
porque te estaría mintiendo. 00:10:07
Si yo me invento una app y te la devuelvo, 00:10:08
tú te vas a creer que esa app es la que estaba en el almacén. 00:10:10
No te puedo mentir. 00:10:14
Pues, la forma de expresar esa idea de que no estaba la 00:10:16
aplicación es devolverle un null. 00:10:20
A devolverle un null, porque un null es un objeto también. 00:10:22
Entonces, siempre que hay que devolver un objeto, 00:10:27
se puede devolver null, porque un null es un objeto. 00:10:29
Lo que pasa es que es un objeto null. 00:10:31
Si este método devolviera string, 00:10:35
returnNull también sería válido, porque null es un objeto. 00:10:37
Null lo puedo devolver siempre que necesite yo devolver un 00:10:42
objeto. 00:10:45
Pero, claro, tengo que devolver null cuando tenga sentido dentro 00:10:46
de lo que yo quiero expresar. 00:10:49
Y aquí está claro, una app tengo que devolver. 00:10:52
Si entro por este camino, la voy a devolver. 00:10:55
Genial. 00:10:57
Pero si no entro por aquí y llego aquí, 00:10:58
pues tengo que devolver null. 00:11:01
Repito, porque la alternativa si no sería construirme yo una app 00:11:04
y devolver esa. 00:11:07
Pero es que entonces estoy confundiendo. 00:11:09
Parecería que esa app que me construí y devuelvo es la del 00:11:11
almacén. 00:11:14
Y no, no había ninguna en el almacén. 00:11:14
Vale, entonces devuelvo null. 00:11:18
Esta sería la forma de hacerlo. 00:11:19
Vale, vale, ahora. 00:11:23
Vale, entonces, cuando uno hace métodos de clases, 00:11:26
tiene que documentar estas cosas y decir, oye, 00:11:30
este método devuelve null si no encuentra aplicación. 00:11:34
Para que el que lo use sepa que se puede encontrar un null si 00:11:38
no lo encuentra. 00:11:42
Y esté prevenido el de los posibles null pointer excepción 00:11:44
cuando el use ese método, etcétera. 00:11:47
Entonces, vale. 00:11:50
Pues, hombre, lo ideal, si hacemos bien las cosas, 00:11:51
es documentar esto. 00:11:54
Nombre de la aplicación a buscar en el array. 00:11:57
¿Qué devuelve? 00:12:07
Con lo de la copia nos metemos ahora. 00:12:10
Voy a poner lo que devuelve de verdad, 00:12:13
aunque tal y como lo tenemos no es eso. 00:12:15
Pero, bueno. 00:12:17
Una copia de la aplicación del, buscar en él, 00:12:19
voy a llamarlo store para que quede claro. 00:12:27
Una copia de la aplicación del store. 00:12:31
O null, o null si no la encuentra. 00:12:41
Vale, esto ya está bien documentado. 00:12:48
Con esto podríamos generar el jabado, 00:12:51
como generamos el otro día. 00:12:52
Si lo enlazamos con el eclipse, que es lo que el otro día se 00:12:54
quedó por hacer, por eso no veíamos la ayuda en línea. 00:12:57
Si lo enlazamos con el eclipse o exportamos el puente, vamos. 00:13:00
El que desarrolle con el eclipse verá la ayuda en línea y verá 00:13:03
esto que hemos explicado y dirá, ah, qué bien, vale, estupendo. 00:13:06
Cuidado, voy a usar install, pero cuidado, 00:13:10
porque puede ser null si no lo encuentra, vale. 00:13:12
Si no, hombre, si no documentamos las cosas, 00:13:15
el que use luego nuestra aplicación esta para su móvil, 00:13:18
pues, a lo mejor, luego no va a poder desarrollar sobre ella. 00:13:23
Vale, bueno, entonces, esta primera versión de método que 00:13:27
hemos hecho no es exactamente la que nos piden, 00:13:30
porque esta, ¿qué es lo que hace? 00:13:33
Devuelve directamente el objeto del array. 00:13:35
Devuelve directamente, no una copia. 00:13:38
Es decir, vámonos al paint ese. 00:13:40
Estupendo. 00:13:45
Vale, a ver, este es nuestro array de aplicaciones. 00:13:56
La propiedad de store está de aquí. 00:14:00
Jolines, vamos a ver, que este, ah, está aquí. 00:14:01
Es que este paint no lo he usado nunca, creo. 00:14:17
De verdad, estoy imbécil. 00:14:24
Ah, sí, vale. 00:14:26
Entonces, ahora, bueno. 00:14:28
Joe, bueno, vale, da igual. 00:14:43
Vale, esta es nuestra propiedad de store de la clase, 00:14:46
la que tiene las aplicaciones, que tiene unas cuantas. 00:14:49
Las que se ha inicializado en el constructor. 00:14:53
Tiene unas cuantas. 00:14:55
Esto. 00:14:59
Vale, ¿qué hace mi método install? 00:15:00
A ver si consigo hacerlo más grande. 00:15:03
¿Qué hace el método install cuando yo le paso un nombre? 00:15:11
¿Qué hace este método? 00:15:21
Bueno, pues, tal y como yo lo he programado, 00:15:22
este método empieza a recorrer el array. 00:15:24
Y cuando encuentra una aplicación aquí en el array, 00:15:27
en la posición que sea, cuyo nombre es el nombre este que 00:15:31
me han pasado, cuando lo encuentra, 00:15:34
devuelve directamente esto. 00:15:37
Directamente la aplicación es la que devuelve con orden retorno. 00:15:40
Directamente este objeto. 00:15:45
¿Veis? 00:15:48
Devuelve directamente ese objeto. 00:15:49
Que ya sabemos nosotros, por otra parte, 00:15:53
que es una dirección de memoria. 00:15:55
Ya lo sabemos, que es una dirección de memoria. 00:15:57
Esto, en realidad, como es un objeto aplicación, 00:15:59
esto sabemos que es una dirección de memoria hacia 00:16:01
donde está la app, en realidad. 00:16:04
Pero el retune es directamente de store de i, directamente. 00:16:06
Es el retune de eso. 00:16:09
Luego, no está devolviendo una copia. 00:16:12
Entonces, esto se supone que trata de simular que, pues, 00:16:16
tú lanzas una aplicación en el móvil y se está ejecutando, 00:16:20
que es después de hacer el install. 00:16:24
Pero lo que tú realmente estás lanzando y ejecutando es una 00:16:27
copia del software de base. 00:16:30
Entonces, si ese software que está conectado a la Play Store 00:16:33
o lo que sea, cambia de versión, el tuyo que se está ejecutando 00:16:36
no cambia, porque es una copia, ¿verdad? 00:16:39
No cambia. 00:16:41
Entonces, si tú quieres actualizar a la versión, 00:16:42
pues, tendrías que actualizarle y volver a instalar la nueva. 00:16:44
Es decir, estos serían tus softwares posibles que están 00:16:48
ahí, pues, en el firmware o donde sea. 00:16:52
Y después del install te haces una copia, 00:16:55
que es la que se ejecuta. 00:16:57
Es lo que intentas simular. 00:16:59
Bueno, pues, el install tiene que devolver una copia de esto, 00:17:01
no esto, una copia, ¿vale? 00:17:05
Vale, pues, entonces, vamos a modificarlo para que vuelva una 00:17:08
copia. 00:17:13
A ver si esto que hago os gusta. 00:17:15
Venga, a ver si esto que hago os gusta. 00:17:18
INTERLOCUTOR 1. Entonces, necesitas un método para 00:17:20
instalarla y es lo que vas a usar. 00:17:22
INTERLOCUTORA 1. ¿Perdón? 00:17:23
INTERLOCUTOR 1. Necesitas un método para instalarla. 00:17:24
INTERLOCUTOR 1. Y es lo que vas a usar. 00:17:27
INTERLOCUTORA 1. Sí, o sea, este install la pone en memoria, 00:17:28
pero no está lanzando a ejecutar. 00:17:30
Este install sería como cargarla en memoria, ¿vale? 00:17:33
Como cargarla, ¿vale? 00:17:35
Pero en cualquier caso cargas una copia, ¿vale? 00:17:36
Eso sí, cargas una copia. 00:17:39
Vale, entonces, este install lo cargas en la memoria RAM, 00:17:42
pero una copia de lo que tienes tú en tu, 00:17:46
lo cargas en la memoria RAM. 00:17:48
Vale, vamos a ver si ahora esto os gusta como para devolver, 00:17:50
como idea de devolver copia. 00:17:53
INTERLOCUTOR 1. Si quieres, me refiero a que cuando no la 00:17:57
tienes, la abres y la buscas a instalar. 00:18:00
Lo primero que te instala es la app que tengas en la RAM. 00:18:02
¿Listo? 00:18:07
La abres y nada. 00:18:09
INTERLOCUTORA 1. Sí, y luego, sí, la parte de ejecutar. 00:18:09
INTERLOCUTOR 1. Sí, después, cuando ya tengas instalada. 00:18:12
INTERLOCUTORA 1. La ejecutas. 00:18:14
Sí, sí, sí, pero esa parte todavía no nos han pedido, 00:18:15
sí, pero esa parte, tenemos un método de ejecutar al que 00:18:17
podríamos llamar, pero no nos han pedido que la ejecutemos. 00:18:19
O sea, nos han dicho, instale solamente para cargarla. 00:18:21
INTERLOCUTOR 1. ¿Y para qué vamos a hacer la copia? 00:18:24
INTERLOCUTORA 1. Bueno, porque funciona así. 00:18:27
Porque lo que tienes que simular es que lo que tienes en memoria 00:18:29
RAM no es directamente, físicamente, 00:18:33
los bits que tienes en el disco duro. 00:18:36
Siempre son copias. 00:18:38
Es lo que intentas simular. 00:18:39
Pues, eso es una copia. 00:18:41
O sea, no es lo mismo. 00:18:43
Es como, a ver, tú tienes. 00:18:45
INTERLOCUTOR 1. Una vez ya la has instalado, 00:18:46
ya no tienes eso, estás creyendo. 00:18:48
INTERLOCUTORA 1. Claro. 00:18:49
A ver, espera, esto es como, vamos a ver. 00:18:50
Tú tienes en el disco duro tu ordenador, 00:18:53
tienes tu sistema operativo, está en el disco duro. 00:18:54
Está en el disco duro. 00:18:56
Cuando tú arrancas, esos bits del disco duro, 00:18:58
que son tu sistema operativo, esos bits se van a la RAM. 00:19:01
Vale, entonces, tú tienes bits en el disco duro y bits en la 00:19:05
RAM, que no son los mismos. 00:19:08
O sea, pueden tener el mismo contenido, pero son copias. 00:19:10
Vale, pues, esa es la idea. 00:19:13
Lo que vamos a simular es que lo que te devuelve el objeto es 00:19:14
una copia. 00:19:19
Ya está. 00:19:20
Si lo único que queremos simular es la idea de copia, 00:19:20
copia de objeto o mismo objeto. 00:19:23
Vale. 00:19:26
O sea, tú cuando tienes un sistema operativo ejecutándose, 00:19:26
lo estás ejecutando de lo que se ha cargado en la RAM. 00:19:29
No lo ejecutas desde el disco duro nunca, ¿verdad? 00:19:32
Pues, eso. 00:19:34
Lo único que quiero decir es que en el disco duro hay unos bits 00:19:35
y en la RAM hay otros. 00:19:40
Y para conseguir los que están en la RAM, 00:19:41
los has conseguido haciendo previamente una copia. 00:19:43
Ya está, nada más. 00:19:46
¿Vale? 00:19:47
¿Vale? ¿Ya está? 00:19:48
Bueno, pues, entonces, vamos a ver si os gusta cómo copia esta 00:19:49
solución que voy a hacer yo aquí. 00:19:56
Vale, pues, entonces, no queremos devolver esto, no. 00:20:00
Lo voy a comentar porque esto era lo que no nos gusta porque 00:20:04
esto no es copia. 00:20:06
Esto es el propio objeto. 00:20:08
Esto es lo que hemos quitado porque esto es el propio objeto, 00:20:10
el que yo devolvería con el retún. 00:20:18
¿Sería este mismo que yo devolvería? 00:20:20
No. 00:20:21
Queremos hacer una copia del objeto. 00:20:22
Vale. 00:20:24
Pues, voy a ver si esto os gusta como copia del objeto. 00:20:24
Vamos a ver. 00:20:28
Me hago un objeto a, a, no tengo ni variable, se llame a, ¿no? 00:20:29
Y en el objeto a, guardo este. 00:20:38
Y ahora devuelvo a. 00:20:44
¿Vale? 00:20:51
¿Vale? 00:20:54
Es otra cosa que he hecho. 00:20:57
Me he hecho un objeto a. 00:20:59
En este objeto a, copio esto, lo que yo antes estaba devolviendo 00:21:00
directamente. 00:21:05
Copio esto. 00:21:06
Y ahora devuelvo a. 00:21:07
¿Vale? 00:21:09
Estamos pensando en objetos. 00:21:10
Vale. 00:21:14
Mi pregunta es, ¿ahora ya estoy realmente devolviendo una copia 00:21:15
del objeto o no? 00:21:19
¿No? 00:21:23
Estoy creando otra dirección. 00:21:30
No, no, no. 00:21:32
No estoy creando ningún objeto. 00:21:33
Estoy creando otra dirección de memoria que lleva al mismo 00:21:34
objeto. 00:21:37
¿Vale? 00:21:39
Esto es lo que estoy haciendo. 00:21:39
A ver. 00:21:41
Yo tengo aquí mi objeto, store de i, 00:21:43
vamos a suponer que es este de aquí, 00:21:46
el que yo quiero devolver. 00:21:49
Este de aquí. 00:21:50
¿Vale? 00:21:51
Entonces, con a, ¿qué estoy creando? 00:21:52
Con a estoy creando. 00:21:54
Entonces, este store de i, como es un objeto a, 00:21:56
esto en realidad es una dirección de memoria hacia el 00:22:00
verdadero objeto. 00:22:04
¿Vale? 00:22:06
O sea, esta es la aplicación de verdad. 00:22:06
Esta de aquí. 00:22:09
El objeto app está aquí. 00:22:11
Joder, no se ve nada. 00:22:13
Vale. 00:22:15
Vale, esto es lo que yo tengo. 00:22:27
Y este es store de i que está aquí. 00:22:28
Bueno, esta es más o menos la situación. 00:22:41
Esta es store de i que en realidad es una dirección de 00:22:45
memoria, es una dirección de memoria al verdadero objeto. 00:22:48
Eso está claro, ¿no? 00:22:50
Es lo que hemos visto siempre. 00:22:51
Esto es una ray de objetos, por lo tanto, 00:22:53
es una ray de direcciones de memoria donde cada una es una 00:22:55
dirección de memoria al objeto. 00:22:58
Vale. 00:23:00
Ahora, ¿qué estoy haciendo cuando yo hago esto de aquí? 00:23:01
Esta línea. 00:23:06
Cuando yo hago esta línea. 00:23:07
Cuando yo hago esta línea, estoy creando una variable a. 00:23:09
Eso está claro. 00:23:14
Una variable a. 00:23:16
Hasta ahí está claro. 00:23:20
Estoy creando una variable. 00:23:21
Estoy creando una dirección adicional. 00:23:25
Estoy creando esto. 00:23:27
Claro, jolines, que yo quiero una cosa grande ahí. 00:23:31
Leches, qué torpe. 00:23:34
A ver. 00:23:37
Ala, y ahora pincho. 00:23:39
Ahora, sí. 00:23:43
Bueno, vale. 00:23:45
Vale, entonces, claro. 00:23:48
Entonces, ¿qué estoy haciendo con A, P, A? 00:23:51
Estoy creando una dirección de memoria a la que le estoy 00:23:55
asignando esto que hay aquí. 00:23:58
Entonces, como le estoy asignando esto que hay aquí, 00:24:01
esta dirección de memoria me está apuntando aquí también. 00:24:03
Con lo cual, me da igual hacer retuneStoreDei, 00:24:07
retuneA, como si me hago 200 aún. 00:24:11
¿Me da lo mismo? 00:24:14
No estoy devolviendo ninguna copia. 00:24:15
Aquí nadie ha creado ninguna copia de nada. 00:24:17
Aquí sigue habiendo un único objeto. 00:24:19
Me da igual hacer retuneStoreDei, 00:24:22
que hacer retuneA, que hacer lo que sea, 00:24:24
porque sigo devolviendo el mismo objeto. 00:24:26
No he creado ninguna copia. 00:24:28
Y no es eso lo que me piden. 00:24:31
Lo que me piden es, no, haz una copia de este, 00:24:32
haz una copia de este y devuelve la copia. 00:24:35
Es lo que me están diciendo. 00:24:39
Lo que me están diciendo que haga es, no hagas esto, 00:24:41
haz una copia del objeto otra. 00:24:44
¿Y qué significa una copia? 00:24:47
Una copia significa que tenga los mismos valores. 00:24:49
Lo que viene a ser un clon, que es distinto. 00:24:52
Es distinto. 00:24:56
Esto sí es una copia. 00:24:58
Otro objeto que tiene los mismos valores. 00:24:59
Es una copia. 00:25:02
Y te dicen, hazme una copia, un clon, 00:25:03
algo que tenga los mismos valores y devuélveme una 00:25:06
dirección a esa. 00:25:11
Eso es lo que me dice. 00:25:13
Dice, oye, no, devuélveme esto, una dirección a esta, la copia. 00:25:14
No me devuelvas una dirección al mismo. 00:25:17
Devuélveme esto. 00:25:19
Con la idea de que lo que está instalado es una cosa y lo que 00:25:21
tienes todo el dígito es otra. 00:25:24
Y ya van por libre, ya van por libre. 00:25:27
Bueno, pues, entonces, para hacer esto, 00:25:34
tenemos entonces que crear un objeto nuevo, 00:25:37
instanciarlo de nuevas, copiar las propiedades y ahora ya sí 00:25:40
devolver eso. 00:25:44
Entonces, para hacer esto que hemos dicho, 00:25:46
que es ya crear una copia de verdad y devolver la dirección 00:25:48
de esa copia, tendremos que hacer ya, pues, 00:25:51
en lugar de esto de aquí que tampoco nos vale, 00:25:54
todo esto fuera, pues, tendremos que hacer. 00:25:57
Vamos a crear un objeto app, pero nuevo enterito, 00:26:02
una instancia nueva. 00:26:05
App de a igual a new app. 00:26:07
Y qué bien que tengamos el constructor sin parámetros. 00:26:12
Con esto ya me he hecho este cuadradito. 00:26:15
Ya me he hecho este cuadradito. 00:26:20
Ya me he hecho esto. 00:26:22
Ahora ya sí que tengo un objeto distinto. 00:26:23
Porque he hecho un new. 00:26:25
He hecho un new e instanciado uno distinto. 00:26:26
Ya sí que tengo esto. 00:26:28
Ahora, ¿qué me falta? 00:26:30
Copiarle las propiedades, copiárselas. 00:26:32
Es lo único que me falta, copiárselas. 00:26:34
Y ya tendré una copia, un clon. 00:26:36
Vale, pues, entonces, ahora ya se tratará simplemente, 00:26:41
vamos a setearle las propiedades. 00:26:44
El nombre, pues, que sea story de i punto get nombre. 00:26:46
Y lo mismo para la dirección y lo mismo para la dirección. 00:26:58
Para la versión y lo mismo para el tamaño. 00:27:03
Set versión, story de i punto get versión. 00:27:10
Y lo mismo para el tamaño. 00:27:19
Apunto set tamaño, story de i punto get tamaño. 00:27:21
Esto sí es otro objeto diferente, pero con los mismos datos. 00:27:35
Esto sí es un clon. 00:27:39
Y ahora nos falta devolverlo, obviamente. 00:27:43
Si no lo devuelvo, pues, no hemos hecho nada. 00:27:45
Esto sí. 00:27:52
Entonces, esto no devuelve una copia. 00:27:53
Devuelve una dirección del mismo objeto. 00:27:56
Esto tampoco. 00:27:58
Devuelve una dirección del mismo objeto. 00:27:59
Esto sí. 00:28:01
Ha creado un objeto distinto. 00:28:02
Distinto, que es este. 00:28:05
¿Y lo que está arriba qué es? 00:28:07
¿Qué es lo que está arriba? 00:28:09
¿Vuelve el new? 00:28:11
¿El bloque qué es? 00:28:14
Esta es a, la dirección de memoria, a, esta es a. 00:28:16
Ah, vale, pero eso es lo que has creado. 00:28:18
Claro, claro, esto es a. 00:28:19
Bueno, a ver, pero es que, a ver, espera. 00:28:21
Lo que tú has creado con el new, vamos a ver. 00:28:25
Esta línea, espera, espera, calma. 00:28:27
Escúchame. 00:28:31
Silencio. 00:28:32
Esta línea tiene dos partes, obviamente. 00:28:34
La parte de declaración, la a, y la parte de distanciación. 00:28:37
Entonces, con el new, lo que se crea es esto. 00:28:41
Y lo que tú estás devolviendo es la dirección. 00:28:45
Claro, pero es que la dirección te apunta al objeto. 00:28:48
No, no, no, no, no, no, no, no, no, no, no, no, no, no, no. 00:28:51
Vale. 00:28:53
¿Ha quedado claro igualmente? 00:28:55
¿Sí? 00:28:57
Eres muy. 00:29:00
No, no. 00:29:00
¿Qué más te voy a decir? 00:29:05
Bueno, lo importante es que haya quedado claro. 00:29:08
¿Vale? 00:29:09
¿Está claro? 00:29:10
Bueno, pues, entonces, devolvemos el objeto. 00:29:14
Entonces, lo que tenéis es que, obviamente, 00:29:16
manejar y entender que direcciones de memoria, 00:29:19
objetos, son cosas que van unidas. 00:29:22
¿Vale? 00:29:26
Entonces, manejamos indistintamente instancia, 00:29:26
dirección de memoria, objeto. 00:29:28
¿Vale? 00:29:30
Entonces, esto sí es una copia. 00:29:31
Y es importante, es importante distinguirlo porque muchas 00:29:33
veces necesitamos trabajar con copias de objetos en lugar de 00:29:38
con el propio objeto. 00:29:43
Lo necesitamos. 00:29:44
Y no nos damos cuenta. 00:29:45
Creemos que estamos trabajando con copias. 00:29:46
Hacemos cosas con esos objetos. 00:29:48
Y, en realidad, estamos modificando el otro. 00:29:50
Entonces, siempre hay que tener muy claro estas cosas. 00:29:53
¿Vale? 00:29:56
Simplemente por eso. 00:29:57
Porque hay situaciones en las cuales yo quiero copias, 00:29:58
no quiero el propio objeto. 00:30:01
Porque quiero modificar solo en una situación, 00:30:04
no quiero modificarla en todas. 00:30:07
Entonces, me hago una copia para esa situación, etcétera, 00:30:08
etcétera. 00:30:11
¿Vale? 00:30:12
¿Vale? 00:30:13
Entonces, esto es hacer un clon que lo hemos hecho a mano. 00:30:14
Pero hay una interfaz clonable que ahora mismo todavía no 00:30:17
podemos entender para hacer clones precisamente por eso. 00:30:19
Porque esta es una situación que podemos necesitar. 00:30:23
¿Vale? 00:30:25
Vale. 00:30:28
A ver, ¿qué más métodos tenemos? 00:30:29
Venga, ¿queréis que lo dejemos aquí? 00:30:36
Venga, pues dejémoslo aquí. 00:30:39
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
28 de enero de 2024 - 18:59
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
30′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
136.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid