Saltar navegación

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

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

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, aquí el diseño ya viene hecho en realidad, no tenemos que decidir las clases, pero tenemos 00:00:00
que entenderlo un poco, entonces, aquí nos dicen ya, la clase esta de aquí, la clase 00:00:10
esta de aquí es la clase que se corresponde con la aplicación, es una aplicación que 00:00:18
gestiona aplicaciones que puede tener un móvil, descargadas, descargadas, en memoria, un poco 00:00:26
todo eso, entonces, eso es una cosa un poquito más complicada de diseñar que una aplicación 00:00:33
de clientes o pedidos o una aplicación de un taller, porque una aplicación de un taller 00:00:37
en cuanto uno haga un análisis así y lo mire un poquito por encima rápidamente sacará, 00:00:41
ah vale, pues coche, será un empleado, factura, pues rápidamente podría sacar un diseño 00:00:46
de clases, esto es como más raro, bueno, pero ya nos dan las clases hechas, pues venga, 00:00:54
habrá una clase app que modeliza una aplicación para móvil, vale, entonces, cada aplicación 00:01:00
que puede tener un móvil es una entidad de lo que yo voy a gestionar, que son aplicaciones 00:01:07
para móviles, pues cada aplicación que puede tener un móvil se modeliza con una clase 00:01:13
app, vale, entonces, el siguiente paso natural, vale, pues porque voy a caracterizar cada 00:01:18
aplicación, uno pues haría un diseño en función de lo que le interesa registrar de 00:01:25
cada aplicación que está en su móvil, pero aquí el diseño ya está hecho y te dicen, 00:01:30
bueno, cada aplicación móvil se va a caracterizar por nombre, versión y tamaño de la aplicación, 00:01:34
y luego, además, cada aplicación que puede hacer, ejecutarse, vale, entonces, como cada 00:01:42
aplicación lo que puede hacer es ejecutarse, pues tendrá un método ejecutar, entonces, 00:01:49
ese método ejecutar que sería el que se invocara, pues cuando se le da el botón de ejecutar la 00:01:55
aplicación, ese método ejecutar, en este caso, simplemente mostrará un mensaje, en lugar de 00:02:01
lanzar un proceso o lo que sea, mostrará un mensaje, entonces, vale, esta clase, pues una 00:02:07
vez que ya el diseño está decidido, no tiene mayor dificultad programar esta clase, luego ya 00:02:13
viene otra que es la tienda o el almacén de aplicaciones, entonces, el almacén de aplicaciones, 00:02:20
el almacén de aplicaciones tendrá todas estas, un conjunto de aplicaciones, vale, entonces, 00:02:28
el almacén de aplicaciones tendrá un conjunto de aplicaciones, un conjunto de estas, vale, bueno, 00:02:36
pues un array, lo que sea, vale, y aquí ya empiezan los métodos que tiene que tener, etcétera, luego, 00:02:41
la clase móvil, ya tenemos tres entidades relacionadas con esta aplicación, la clase 00:02:50
app para cada aplicación, la clase almacén de aplicaciones y luego la clase el teléfono en sí, 00:02:56
el teléfono, es un diseño posible, se podría haber adoptado por otros diseños, esta es la clase el 00:03:04
teléfono, vale, el teléfono tendrá sus apps instaladas, tendrá sus rollos y luego la clase 00:03:10
principal, la clase principal, bueno, pues entonces, una vez que uno se ha echado un vistazo por encima 00:03:18
y se hace una idea de de qué va esto, pues esto va de una aplicación que gestiona las, de una 00:03:29
aplicación que gestiona las aplicaciones que un móvil tiene instaladas y que además puede ejecutar, 00:03:35
gestiona eso, gestiona lo que tiene descargado y lo que puede ejecutar, bueno, pues de esto va, de 00:03:40
esto va la aplicación, pero uno tiene que entender siempre cuando tiene que hacer una aplicación de 00:03:47
qué va, en este caso cuando tiene que programarla, tiene que entender de qué va, bueno, pues esto, 00:03:51
una vez hecho una lectura entera va de eso, va de un programa que te gestiona las aplicaciones que 00:03:56
tiene instaladas un móvil y las puede ejecutar, bueno, pues va de eso y significa que el diseño, 00:04:03
y ha implicado que el diseño es, una clase app para cada aplicación, una clase almacén de 00:04:13
aplicaciones y una clase el propio teléfono, vale, bueno, pues entonces uno ya, una vez que ya más o 00:04:18
menos sabe de qué va esto y ya no le va a sonar a chino las cosas que escriba, puede empezar a 00:04:25
plantearse a programarla, pues venga, lo primero, esta clase no tiene ninguna dificultad, venga, 00:04:31
en dos minutos, la hacéis a la vez que yo, venga. 00:04:40
Vale, simplemente habréis hecho algo así, la clase, vale, entonces ya en aplicaciones que hay 00:04:55
varias clases, recordad que uno debería ya hacer siempre, acostumbrarse a hacer siempre paquetes, 00:05:08
en nuestro caso no porque sea tan imprescindible, porque son tres, cuatro, cinco clases, no son 00:05:14
tantas, pero si es bueno que vayamos entendiendo que las clases pueden tener diferentes significados, 00:05:20
entonces hay unas que tenemos que tener muy claras, que son las clases que están asociadas a entidades, 00:05:32
lo que repetimos siempre, entonces esas clases que están asociadas a entidades de mi aplicación, 00:05:37
se suelen meter en un paquete aparte, entonces tenéis que familiarizaros ya con esa forma de 00:05:42
desarrollar las aplicaciones, ese paquete aparte, que se puede llamar entities, como uno le dé la 00:05:48
gana, yo ahora he cambiado pues para que os vayan sonando los nombres de todo, lo he llamado modelo, 00:05:56
vale, el modelo de una aplicación, el modelo es el diseño de clases entidad de las que consta, 00:06:03
ese es el modelo, en nuestra aplicación anterior su modelo era, teníamos una factura, perdón, 00:06:11
una factura no, teníamos pedidos, teníamos clientes que podían hacer pedidos y teníamos 00:06:18
ítems dentro de los pedidos, esas tres clases eran el modelo, las metíamos en un paquete aparte, 00:06:24
bueno pues, ir familiarizando con esa nomenclatura, con esa forma de hacer las cosas, poco a poco, 00:06:31
irla interiorizando, iros empapando de esa manera, pero luego llegáis a entrevistas de trabajo y no 00:06:41
manejáis los términos, no estáis en el contexto en el que hay que estar, no vale hacer programas, 00:06:45
o hecho un programa estupendo, no, para estar uno en su casa y disfrutarlo sí, pero para salir al 00:06:51
mundo a la hora de trabajar y que os cojan, no vale, vale, entonces iros empapando un poco de 00:06:58
esto, bueno, pues yo he hecho un paquete modelo, con su nombre, uno de los nombres habituales, 00:07:02
donde voy a meter las entidades que representan mi realidad a gestionar o mi modelo, vale y en 00:07:07
esa aplicación app, en esa aplicación app, pues había poco que decidir, las tres propiedades, 00:07:16
no sé qué tipo de dato habréis seleccionado, igual otro, da igual, vale, nombre, versión, 00:07:22
tamaño, lo habitual, un constructor que recibe parámetros para inicializar el objeto ya con 00:07:28
valores y un constructor sin ninguno, útil, si yo quiero crear un objeto app, pero todavía no tengo 00:07:35
las propiedades, getter y setter públicos, para poder acceder a las propiedades que lo normal 00:07:41
es poner privadas, getter y setter públicos y ahora ya, qué puede hacer una aplicación, qué acciones 00:07:47
están relacionadas dentro de mi aplicación gorda con esta clase, pues ejecutar una app, una app en 00:07:54
particular lo que puede es ejecutar, bueno pues tiene sentido poner ahí su método ejecutar, entonces 00:08:02
como lo que hace este método simplemente es mostrar un mensajito, pues devuelve void y no recibe nada, 00:08:08
no recibe nada, vale, entonces este método podría ser estático, Edison, podría serlo el método que yo 00:08:15
he escrito ahí, podría yo ponerle static delante del void, no, por qué no, no te acuerdas, pero sabes que no, bueno tienes un círculo de anteposibilidades, 00:08:29
Andoni, podría ser estático ese método, yo le puedo poner un static delante del void, no, por qué no, 00:08:41
David, podría poner un static delante del void, 00:08:59
Daniel, 00:09:11
a ver, Mario, por qué no, a ver no vale que pongáis el static, yo no soy rojo que digáis no, 00:09:20
le hago un 5 que no me da la explicación, Ismael, 00:09:29
en principio sí, puedo poner el static, a ver en programación las cosas no son en principio al final, sí o no, sí, por qué, 00:09:39
pero eso no es el concepto de static, el método no lo usa otra clase, no tiene nada que ver, 00:09:47
sería esa la razón, a ver, Daniel, podría poner yo ahí static delante del void, no, por qué no, 00:09:58
Moisés, podría poner el static delante del void, por qué no, 00:10:16
esa explicación como tal, en un antepasibilidad, se la das a un jefe y te echa del trabajo, 00:10:36
no tiene una explicación bien dada, 00:10:43
a ver, Diego, una explicación bien dada, en alto porfa de nuevo, 00:10:51
no, porque no puedes instanciar las variables, 00:11:03
no veo la conexión, yo tampoco la veo, a ver, Adrián, podría poner un static, sí o no, y por qué no, 00:11:06
vale, esa sí es la respuesta o casi la respuesta, pero sí, vamos a ver, este método depende de propiedades del objeto, 00:11:22
con lo cual este método depende del objeto que lo llame, para el objeto app que se llame Google Play, 00:11:32
aquí pondrá Google Play, para el objeto app que se llame Spotify, aquí pondrá Spotify, 00:11:41
con lo cual este método depende de una propiedad de la clase que es esta, depende, 00:11:49
depende, con lo cual funciona de forma distinta lo llame el objeto que lo llame, 00:11:55
no, porque depende de una propiedad que no es estática, efectivamente, 00:12:00
con lo cual no es un método estático, por definición, un método estático es un método que da igual el objeto que lo llame, 00:12:05
da lo mismo, porque va a hacer lo mismo, porque no depende de las propiedades del objeto en particular, 00:12:11
vale, esa es la respuesta, vale, no puede serlo porque depende de propiedades del objeto, 00:12:18
entonces, necesito llamar al método para un objeto en concreto, vale, 00:12:25
si este método dijera esto, vale, este método podría ser estático, 00:12:35
obviamente sí, porque este método sí que da igual el objeto que lo llame, 00:12:49
va a hacer lo mismo, que es mostrar un mensaje en consola, va a hacer lo mismo, da igual el objeto que lo llame, 00:12:54
entonces yo podría poner un estático delante y no pasaría nada, vale, efectivamente no pasa nada, 00:13:00
pero hombre, a ver, el sentido de mi aplicación se pierde un poco, 00:13:12
no, eso significa que yo puedo llamar a ese método aunque no exista ninguna clase, 00:13:17
aunque no exista ningún objeto app, eso es lo que significa, verdad, 00:13:22
desde el momento en que el método es estático, y yo lo identifico poniendo el estático delante, 00:13:27
esto significa que yo no necesito que exista ningún objeto app para llamar al método, 00:13:35
lo puedo llamar con el nombre de la clase, vale, pero hombre, pierde un poco el sentido de la aplicación, 00:13:46
se supone que lo que se ejecutan son aplicaciones concretas, 00:13:51
entonces como en este caso no está esta aplicación conectada a un móvil 00:13:54
que lance el proceso de ejecutar la aplicación ni nada, 00:13:59
lo simulamos poniendo un mensaje por consola, lo simulamos, 00:14:02
pero hombre, si mensaje por consola que dependa de la aplicación, 00:14:06
porque es que si no pierde el sentido esta aplicación, vale, 00:14:09
entonces lo que se ejecuta es una aplicación concreto, 00:14:13
por eso le hemos puesto que el subcontenido dependa de una variable del objeto, 00:14:15
dependa para que el método no pueda ser estático y lo tenga que llamar un objeto en concreto, 00:14:21
para que tenga sentido la aplicación, sino que no dejaría de tenerlo, 00:14:25
vale, pues entonces, vale, entonces, 00:14:28
mi papel obviamente es echaros la bronca porque no me contestéis a las cosas que os pregunto 00:14:38
que son muy sencillas después de haberlas insistido un día tras otro, 00:14:45
porque si me decís es porque no te sabes explicar, pues a lo mejor me lo pienso, 00:14:51
pero no creo, sinceramente no creo que sea por eso, 00:14:58
yo creo que es porque no lo estudiéis en casa, creo que es por eso, 00:15:00
y estoy segura del 99%, vale, luego habrá otras razones para otras cosas, 00:15:05
pero para que no me contestéis a estas preguntas que yo os hago 00:15:11
después de haberlo insistido un montón de veces, yo creo que la razón es esa, 00:15:13
y la solución entonces está en vuestra mano, vale, está exclusivamente en vuestra mano. 00:15:18
Más que nada porque, hombre, el beneficio obviamente es para vosotros, 00:15:30
que esto no es que tengo que sacar el título de cuarto de la ESO porque es que es obligatorio, 00:15:35
necesito, no, esto es estoy aquí porque quiero trabajar de esto, 00:15:39
pues entonces solo hay un camino, solo hay un camino, que es currárselo y estudiar, 00:15:44
porque incluso en el mejor de los casos, en el mejor de los casos, 00:15:50
os podréis trasplantar un cerebro, achar GPT en la cabeza y podréis conectaros 00:15:55
y que lo hiciera todo y aprobarais, incluso en ese caso no os vale para nada, 00:15:59
no os vale para nada que hay muchos chavales fuera que han durado un mes en las prácticas, 00:16:03
no os vale para nada, entonces por favor, no perdáis el tiempo que estáis dedicando a estar aquí. 00:16:07
Bueno, y yo no os he hecho la charla por nada personal, obviamente, 00:16:16
sino porque es que es mi obligación. 00:16:20
Vale, pues entonces, la clase A, ¿tú de qué te pones? 00:16:24
¿Tienes algún comentario que hacerme? 00:16:30
No pasaría nada, yo la cogería. 00:16:33
Sí, seguro que sí, venga, a ver. 00:16:38
Bueno, sobre esta clase está claro, ¿no? Ya está, no hay más. 00:16:45
Vale, pues venga, ahora vámonos a la otra clase que el que ha hecho el diseño ha decidido. 00:16:50
El almacén de aplicaciones, el que gestiona las aplicaciones que se van instalando, 00:16:55
desinstalando, lo que sea. 00:16:59
Vale, esto es la clase aplicación, que es una aplicación que lo único que puede hacer es ejecutarse, ya está. 00:17:01
Y luego otra clase, almacén de aplicaciones, que gestiona las aplicaciones que pueden estar ahí. 00:17:05
Pues venga, esa clase ya está decidida también, que se llame App Store, 00:17:14
y está decidida su propiedad, que es un array de aplicaciones, 00:17:19
porque el almacén de aplicaciones puede tener varias, ¿vale? 00:17:24
Entonces aquí, pues simplemente, pues para cambiar y hacer diferentes cosas, 00:17:28
vamos a hacer un constructor distinto. 00:17:34
Entonces el constructor, que es el que instancia el almacén, 00:17:37
va a recibir un conjunto de aplicaciones para instanciarlos, 00:17:41
pero las va a recibir de una manera muy rara, en un stream, 00:17:46
para que nosotros destripemos el stream y de ese stream saquemos ya cada una de las aplicaciones. 00:17:51
A ver, vamos por partes. 00:17:56
Vamos a empezar con esta clase App Store, que es la siguiente. 00:17:59
Pues venga, dentro del modelo, como esta es una entidad, pues otra clase. 00:18:03
Venga, pues esta tiene propiedades, el conjunto de aplicaciones. 00:18:07
Un conjunto de aplicaciones. 00:18:30
Entonces, por ahora, esperemos ya que por poco tiempo, 00:18:33
para guardar un conjunto de muchas cosas, pues esto es lo único que tenemos. 00:18:37
¿Vale? 00:18:43
Vale. 00:18:46
Entonces, el get y el set sí que vamos a ponérselo, 00:18:50
porque esa es una propiedad privada y desde fuera queremos dar permiso para acceder a ella, 00:18:53
si es que queremos darlo. 00:18:57
El get y el set, pues bueno, vamos a ponérselo. 00:18:59
Vale. 00:19:01
Otra cosa sería que una vez hecha una aplicación, ya funcionando ya, 00:19:03
pues uno dijera, a ver, que las otras clases no van a necesitar nunca hacer ni get ni set 00:19:07
de estos objetos, porque nunca van a quitar leer ni escribir, 00:19:15
pues entonces hasta podría quitar los get y los set. 00:19:18
Cuanto más proteja yo y más encapsule, casi mejor. 00:19:20
Pero por defecto, no. 00:19:24
Cuanto más proteja yo y más encapsule, casi mejor. 00:19:26
Pero por defecto, yo ofrezco get y set. 00:19:29
Vale. Y ahora, el constructor. 00:19:33
El constructor aquí es el raro uno. 00:19:35
¿Vale? El constructor. 00:19:37
Vamos a hacer un constructor que reciba apps para el store, para el almacén, 00:19:39
que reciba apps, pero las va a recibir en un string con esta pinta tan rara. 00:19:44
¿Vale? 00:19:49
Vale. 00:19:50
Entonces, el constructor va a ser, como todos los constructores, 00:19:55
se tendrá que llamar igual que el nombre de la clase, 00:20:02
y va a recibir una cadena. 00:20:05
Y esta cadena es de este estilo. 00:20:17
Es una sucesión de nombre de aplicación, coma, 00:20:20
versión de aplicación, coma, tamaño de aplicación. 00:20:23
Punto y coma. 00:20:26
Patatín, patatín, patatín. Punto y coma. 00:20:28
Entonces, cada uno de estos packs que van en punto y coma, 00:20:30
es todo un string entero. 00:20:34
A ver si lo consigo hacer grande o no. 00:20:40
Vale. 00:20:45
Aquí, a lo mejor, en un ejemplo concreto, 00:20:47
aquí en el ejemplo igual, se ve mejor. 00:20:48
¿Vale? 00:20:51
Entonces, lo que recibe es un string entero. 00:20:52
Y ahora, de este string, tendremos que entrar nosotros, 00:20:55
a ver cómo hacemos, para ir separándolo primero por puntos y comas. 00:20:58
Porque cada punto y coma separa la información de una app en concreto. 00:21:02
Y ahora, entre los puntos y comas, viene la información de una app, 00:21:07
separada por comas. 00:21:12
El nombre, la versión y el tamaño. 00:21:14
Nombre, versión y tamaño. 00:21:18
Nombre, versión y tamaño. 00:21:21
¿Vale? 00:21:24
Pero todo eso que tiene un string. 00:21:26
¿Pero qué pasa? 00:21:28
Que string, como ya sabemos, es una clase. 00:21:30
Entonces, como string es una clase, 00:21:33
ahora ya sabemos que los objetos, 00:21:36
string, como apps, tienen métodos para aburrir. 00:21:41
String no lo hemos hecho nosotros. 00:21:45
Claro, pero esta clase string, 00:21:46
está dentro de la máquina virtual, esta JRE, 00:21:49
y si entramos en ella, en su código, 00:21:52
pues la clase string, que es esta, 00:21:54
esta es la clase string que no hemos hecho nosotros, 00:21:57
pero la estamos utilizando todo el rato, 00:22:00
esta clase string, tiene tropecientos métodos, 00:22:02
algunos estáticos y otros no, 00:22:06
para hacer cosas. 00:22:09
¿Vale? Tiene un montón. 00:22:11
Ya tiene un montón. 00:22:12
¿Vale? 00:22:15
A ver si llego a alguno que podamos entender el nombrecito. 00:22:19
Primero están... 00:22:26
A ver, vámonos muy abajo, a ver. 00:22:28
Get bytes equals... 00:22:31
Bueno, la clase string tiene tropecientos métodos. 00:22:34
El que hizo la clase y la metió en la librería de la JRE 00:22:37
para que nosotros la usemos, 00:22:41
que ya hemos visto varias veces 00:22:43
cómo nuestros proyectos siempre tienen esas clases ahí, 00:22:45
las que pueden usar, ¿no? 00:22:48
Tienen estas, 00:22:50
y las otras, 00:22:52
y las otras, 00:22:54
y las otras, 00:22:56
tienen estas 00:22:57
clases, 00:23:00
¿verdad? 00:23:02
Ahí en la JRE metidas 00:23:04
hay tropecientos mil millones de clases 00:23:06
que nosotros podemos usar si nos da la gana. 00:23:09
¿Vale? Como por ejemplo, 00:23:11
esta que estoy yo mirando, 00:23:13
esta que he abierto, 00:23:15
la clase string. 00:23:17
Entonces, string, 00:23:20
bueno, ahí está, ¿vale? string. 00:23:22
¿Qué es esa? 00:23:24
String es una clase, 00:23:25
más, 00:23:27
qué curioso, esa clase el que la hizo, 00:23:29
¿qué le puso como propiedad? 00:23:31
Pues le puso como propiedad a la clase string 00:23:33
los caracteres que la componen. 00:23:36
¿Veis? 00:23:40
Que la clase string tiene como propiedad, 00:23:42
me he saltado la propiedad, 00:23:47
¿ya o no me la he saltado? 00:23:49
No. 00:23:50
Ahí, clase string, 00:23:52
¿veis? 00:23:54
La propiedad que tiene la clase string 00:23:57
son los caracteres que componen la cadena. 00:24:00
¿Vale? 00:24:04
Los caracteres. 00:24:06
Y luego tiene un montón de métodos 00:24:08
para hacer cosas con esos caracteres. 00:24:10
Nosotros estamos usando los objetos string 00:24:12
como si fueran variables primitivas, 00:24:15
pero ahora ya podemos entender perfectamente 00:24:17
que no lo son. 00:24:18
Cada vez que usamos una cadena, 00:24:20
algo entre dos comillas, 00:24:22
un objeto string es un objeto. 00:24:24
¿Cuál es la propiedad que tiene dentro? 00:24:26
Sus caracteres que estarán guardados aquí en value. 00:24:29
¿Vale? 00:24:32
Lo que pasa es que yo no puedo acceder directamente, 00:24:34
cuando tengo una cadena string 00:24:36
no puedo acceder directamente a punto value 00:24:38
porque es privada, no puedo. 00:24:40
Pero cuando yo tengo un objeto string ese, 00:24:42
si esto en lugar de privado fuera public 00:24:44
yo podría hacer ese punto value 00:24:46
y podría, ¿a dónde estaría accediendo? 00:24:48
A los caracteres que forman la cadena. 00:24:50
¿Vale? 00:24:52
Pero el que hizo la clase string 00:24:54
no me permite acceder así a esos caracteres 00:24:56
porque le ha puesto un private. 00:24:58
¿Qué es lo que hace? 00:25:00
Ofrecerme un montón de métodos, 00:25:02
la tira que tengo por ahí abajo, 00:25:04
para hacer cosas con ese string. 00:25:06
Ver si es igual a otro con equals. 00:25:08
Ver cuál es el carácter de una posición con charAt. 00:25:10
Algunos, muy poquitos los hemos visto, ¿verdad? 00:25:12
Ver qué tamaño tiene ese string 00:25:14
con el punto length. 00:25:16
¿Vale? 00:25:18
El método punto length, 00:25:20
si lo buscamos ahora, 00:25:22
¿qué nos devuelve? 00:25:24
La longitud de este array. 00:25:26
¿Vale? 00:25:28
O sea, cuando nosotros usamos una cadena 00:25:30
y hacemos esto, 00:25:32
por ejemplo, yo aquí tengo apps 00:25:34
y apps es una cadena, ¿no? 00:25:36
Entonces yo puedo acceder a su tamaño 00:25:38
con el método length 00:25:40
porque ya lo hemos hecho muchas veces, ¿verdad? 00:25:42
Imagínate que yo quiero aquí mostrar esto. 00:25:44
Vale. 00:25:46
Directamente diciendo, 00:25:48
cuando tienes un objeto, 00:25:50
una variable string, 00:25:52
puedes mostrar su tamaño con este método. 00:25:54
Vale, pues hemos llamado al método 00:25:56
y nos hemos creído 00:25:58
que este método te devuelve 00:26:00
el número de caracteres del objeto string. 00:26:02
Claro, 00:26:04
porque esto pertenece, 00:26:06
es un objeto que pertenece a la clase string 00:26:08
y esa clase string está aquí hecha 00:26:10
y la estamos usando 00:26:12
y esa clase string 00:26:14
tiene como propiedad interna 00:26:16
y de bytes 00:26:18
que la componen 00:26:20
y luego tendrá un método por ahí abajo, 00:26:22
el length. 00:26:24
Si pude, 00:26:26
¿cuál es el atajo para buscar aquí rápido 00:26:28
en este 00:26:30
control F, verdad? 00:26:32
Lo de los atajos 00:26:34
lo llevo fatal. 00:26:37
¿Vale? 00:26:44
El método length de la clase string, 00:26:46
¿el método que hace? 00:26:48
Te devuelve el tamaño del array value. 00:26:50
Es lo que te devuelve. 00:26:52
Lo que quiero es que 00:26:54
veáis como todo cuadra, 00:26:56
todo casa, 00:26:58
que lo vayáis entendiendo todo 00:27:00
porque esa es la base 00:27:02
de que podéis seguir aprendiendo 00:27:04
y también quiero que veáis 00:27:06
que lo que está en el fondo de todo 00:27:08
siempre son los arrays, 00:27:10
siempre. 00:27:12
En la base de string, por supuesto, 00:27:14
porque es un array de bytes. 00:27:16
Bueno, 00:27:18
pues entonces, todo esto venía 00:27:20
igual que me ofrece el método length 00:27:22
de la clase string, 00:27:24
me ofrece tropecientos métodos. 00:27:26
Pues nuestra forma de trabajo ahora será, 00:27:28
oye, ojo, 00:27:30
que yo necesito 00:27:32
de un string path 00:27:34
que tiene todo este chorizo, 00:27:36
voy a tener que ponerme ahora a trabajar 00:27:38
y a ver cómo hago 00:27:40
para sacarle estas partes, 00:27:42
separarlas en diferentes variables 00:27:44
para luego coger cada una de ellas 00:27:46
y llegar con ella a un objeto app 00:27:48
y darle estos valores. 00:27:50
Bueno, pues entonces, 00:27:52
cuando ya se me plantean esos temas, 00:27:54
digo, a ver, 00:27:56
gracias a la aprobación de todos los objetos, 00:27:58
la clase string seguramente tenga ya 00:28:00
un montón de métodos hechos 00:28:02
que yo puedo usar. 00:28:04
Pues voy a cotillear en ellos 00:28:06
y voy a buscarlos. 00:28:08
A ver si tiene algún método 00:28:10
que me permita separar una cadena 00:28:12
en partes dándole el carácter separador 00:28:14
que me interesa. 00:28:16
Voy a resolver mi problema final 00:28:18
que es 00:28:20
coger cada una de estas porciones 00:28:22
a su vez para cada porción 00:28:24
coger cada una de ellas 00:28:26
y con cada una de ellas 00:28:28
instanciar un objeto app 00:28:30
y pasarlo al array 00:28:32
interno de App Store. 00:28:34
¿Vale? 00:28:36
Y esa es la dinámica habitual. 00:28:38
Uno, cuando tiene que hacer cosas 00:28:40
lo que tendrá que indagar es 00:28:42
si las clases a las que pertenecen 00:28:44
los objetos con las que hace cosas 00:28:46
tienen métodos que le hagan 00:28:48
lo que necesita. 00:28:50
Es lo que tenemos que hacer ahora. 00:28:52
La clase string tiene métodos 00:28:54
que hacen lo que yo necesito 00:28:56
que es dividir en partes. 00:28:58
Bueno, pues es el trabajo ahora. 00:29:00
Pues venga, poneros en un rato 00:29:02
a ver de este constructor 00:29:04
de aquí 00:29:06
que sacamos. 00:29:08
¿Vale? 00:29:10
Entonces el objetivo de este constructor 00:29:12
repito es 00:29:14
recibir esta string 00:29:18
y romper esa string 00:29:20
o sea sacar de ella los datos 00:29:22
para con ella 00:29:24
crear un array 00:29:26
de objetos app 00:29:28
que se guarden en Store. 00:29:30
¿Vale? 00:29:32
Ese es el objetivo de este constructor. 00:29:34
Entonces 00:29:36
en este ejemplo concreto 00:29:38
crearía un array con tres 00:29:40
con cinco, ¿no? 00:29:42
Uno 00:29:44
dos 00:29:46
tres 00:29:48
cuatro 00:29:50
y cinco. 00:29:52
El resultado final de ese constructor 00:29:54
tendría que ser 00:29:56
haber creado un array 00:29:58
de cinco objetos app 00:30:00
para almacendárselo a esta propiedad. 00:30:02
Es decir, es un constructor 00:30:04
que en realidad también está 00:30:06
inicializando la propiedad 00:30:08
pero la está inicializando 00:30:10
en lugar de que yo le pase un array 00:30:12
directamente o igual se lo paso 00:30:14
lo asigna y listo 00:30:16
para construir el array de arriba. 00:30:18
¿Vale? 00:30:20
A ver 00:30:26
claro la idea no es abrir el código 00:30:28
y buscar porque uno se vuelve loco. 00:30:30
Entonces 00:30:32
gracias a la ayuda 00:30:34
a la ayuda del Eclipse 00:30:36
pues ya sabéis que si uno 00:30:38
y el que no lo tenga presente 00:30:40
claro 00:30:43
pues si uno teclea un objeto 00:30:45
de una clase 00:30:46
y da a punto 00:30:48
le salen todos los métodos que tiene 00:30:50
a los que puede llamar por ser de esa clase 00:30:52
y aquí le sale 00:30:54
de todo 00:30:56
cada uno con su ayuda correspondiente. 00:30:58
Entonces aquí 00:31:00
esta tarea es importante 00:31:02
porque es una tarea que hay que realizar 00:31:04
continuamente uno de forma autónoma 00:31:06
que es imposible que uno se sepa 00:31:08
de millones de clases 00:31:10
los millones de métodos. 00:31:12
Entonces uno tiene que desarrollar 00:31:14
los métodos 00:31:16
pero y voy a mirar en los métodos 00:31:18
a ver me valdrá este 00:31:20
por ejemplo este 00:31:22
¿Este qué te hace? 00:31:23
Hombre pues tiene toda la pinta 00:31:25
de que te convierte 00:31:27
el objeto string que llame al método 00:31:29
en un Array de Char 00:31:31
y se lo devuelve. 00:31:33
vale, este substring 00:31:35
la ayuda lo dirá 00:31:37
pero tiene pinta de que lo que hace 00:31:39
es devolverte un string 00:31:41
Lo que te pone a la derecha 00:31:43
que es el substring 00:31:44
que está encerrado 00:31:46
entre este índice y este otro 00:31:48
bueno pues aquí uno va viendo 00:31:50
las posibilidades que tiene 00:31:52
aquí tiene la ayuda 00:31:54
y decide qué métodos 00:31:56
le pueden interesar 00:31:58
para conseguir su objetivo 00:32:00
vale 00:32:02
uno tiene si no siempre 00:32:07
aunque es la misma 00:32:09
la documentación que te ofrece 00:32:11
¿qué te gira de esta? 00:32:12
pues claro 00:32:14
imaginaos que uno quiere buscar 00:32:16
los métodos de una clase 00:32:18
pues yo creo que ya lo primero 00:32:20
que me va a salir 00:32:22
JavaScript no 00:32:24
a ver 00:32:31
no, esto no quiero 00:32:39
quiero la 00:32:40
la documentación oficial 00:32:47
de Oracle 00:32:49
que no, que quiero yo 00:32:54
que me salga 00:32:56
vale 00:32:58
vale esto por ejemplo 00:33:09
vale 00:33:11
vale 00:33:15
fijaos que aspecto tiene esta web 00:33:17
de estilo 00:33:19
de estilo es idéntica 00:33:21
a la web que generamos nosotros 00:33:23
el otro día para documentar 00:33:25
o la que estamos documentando 00:33:27
o la de teclado 00:33:29
tiene el mismo estilo 00:33:31
claro porque es una documentación 00:33:33
JavaDoc generada igual 00:33:35
que generamos nosotros la nuestra 00:33:37
para la clase teclado 00:33:39
igual, generada igual 00:33:41
vale pues esta es 00:33:43
la documentación que tiene Oracle 00:33:45
sobre todas las clases 00:33:47
que distribuyen todas sus JDKs 00:33:49
es la documentación oficial 00:33:51
y uno podría navegar por aquí 00:33:53
y encontrarlo todo 00:33:55
con esa documentación estándar 00:33:57
y lo que nos escribe aquí 00:33:59
cuando 00:34:02
lo que nos escribe aquí a la derecha 00:34:05
cuando nos ofrece la ayuda de un método 00:34:07
es lo mismito que encontraríamos 00:34:09
en esa documentación 00:34:11
lo mismo 00:34:12
vale entonces uno puede encontrar 00:34:13
la explicación de lo que hace cada método 00:34:15
bien a través del eclipse 00:34:17
o bien a través de la web 00:34:19
siempre el eclipse es más cómodo 00:34:20
y a veces es que incluso el propio nombre 00:34:22
si el nombre está bien elegido 00:34:24
ya es que te dice lo que hace 00:34:25
y el tipo de dato que te devuelve 00:34:27
entonces a veces el propio nombre 00:34:29
ya te lo dice 00:34:31
de ahí la importancia de elegir bien 00:34:33
los nombres de los métodos 00:34:35
que os dice en su momento 00:34:37
porque la idea es que cuando uno vea 00:34:39
el nombre de tu método 00:34:41
rápidamente sepa lo que hace 00:34:43
y no le dificultes las cosas 00:34:45
y te va a irse a buscar documentaciones 00:34:47
etcétera 00:34:49
vale 00:34:51
venga pues por favor 00:34:53
empleaos un rato 00:34:55
a ver que sacamos de ese 00:34:57
de ese constructor 00:34:59
vale 00:35:01
pues venga 00:35:03
apps 00:35:05
a ver que métodos tiene 00:35:07
aquí pues claro 00:35:11
cuanto más inglés tenga uno 00:35:13
mejor porque si los métodos 00:35:15
están escritos en inglés 00:35:17
vale 00:35:19
pues estos primeros 00:35:21
contiene bueno 00:35:23
patatín 00:35:25
a ver que vamos a hacer 00:35:27
la búsqueda rápida 00:35:29
indexOf 00:35:31
mira este tiene pinta 00:35:33
de que te dice en qué posición 00:35:35
está un char que tú le pasas 00:35:37
isEmpty 00:35:39
si está vacío 00:35:41
bueno tiene un montón de métodos 00:35:43
laxtIndexOf 00:35:45
tiene pinta de que te dice 00:35:47
en qué posición 00:35:48
en la que está 00:35:50
un carácter que tú le pasas 00:35:52
como parámetro 00:35:54
te da la última posición 00:35:56
bueno hay un montón de utilidades 00:35:58
seguimos por aquí 00:36:00
leen que la conocemos 00:36:02
seguimos 00:36:04
seguimos 00:36:06
entonces 00:36:08
hay una palabra 00:36:10
que todos conocéis del inglés 00:36:12
porque entiendo que sois bilingües 00:36:14
splitting 00:36:16
porque tú estás con tus colegas 00:36:18
y cada uno 00:36:20
tú te dices por aquí, está por aquí 00:36:22
hablo yo más en inglés que vosotros 00:36:24
split 00:36:26
es dividirse 00:36:28
o tú haces un splitting 00:36:30
es porque unos van para acá 00:36:32
otros van para allá 00:36:34
vale pues entonces 00:36:36
split 00:36:38
ya cuando vemos la palabra split 00:36:40
cuando vemos la palabra split 00:36:42
split es dividirse en ramas 00:36:45
en ramas 00:36:46
si uno ve la palabra split ya 00:36:48
pum se le enciende una luz 00:36:50
pero es que encima 00:36:52
cuando ve que lo que devuelve split 00:36:54
es varias cadenas 00:36:56
dice ostras 00:36:58
va a ser que igual va por aquí la cosa 00:37:00
porque 00:37:02
una cadena llama al método split 00:37:04
y me devuelve varias 00:37:06
tiene toda la pinta que lo que me hace 00:37:08
es dividir una cadena en varias 00:37:10
que es justo lo que estamos buscando 00:37:12
dividir una cadena en varias 00:37:14
a ver si este es el método que queremos 00:37:16
vale pues 00:37:18
nos vamos a la ayuda de split 00:37:20
y nos dice 00:37:22
efectivamente 00:37:24
divide esta cadena 00:37:26
alrededor 00:37:30
de los caracteres 00:37:34
del patrón que tú le pasas como parámetro 00:37:36
¿verdad? 00:37:38
te pone aquí ejemplos y todo 00:37:40
entonces 00:37:42
efectivamente 00:37:44
si tú le pasas 00:37:46
aquí un string 00:37:48
entonces si tú le pasas un string cualquiera 00:37:50
te divide 00:37:52
en todas las subcadenas 00:37:54
que quedan divididas 00:37:56
que están separadas 00:37:58
por ese patrón que tú le pasas aquí 00:38:00
por ese patrón 00:38:02
eso es lo que te viene a decir la ayuda 00:38:04
y tiene un ejemplito abajo y todo eso 00:38:06
pero claro aquí la palabra clave es que uno ve split 00:38:08
y sobre todo que ha visto 00:38:10
que lo que devuelve 00:38:12
son varias cadenas 00:38:14
una cadena llama split 00:38:16
y obtenemos varias 00:38:18
suena que es lo que queremos 00:38:20
dividir una cadena en varias 00:38:22
a ver 00:38:24
tú aquí con esto ves 00:38:26
bueno pero 00:38:32
a ver un string puede tener un solo carácter 00:38:34
entonces es más general 00:38:36
a lo mejor el separador no tiene que ser solo un char 00:38:38
el separador puede ser dos puntos y comas 00:38:40
por ejemplo imagínate 00:38:42
entonces es más general 00:38:44
entonces 00:38:46
el nombre lo que te devuelve 00:38:48
te hace ver que puede ser eso 00:38:50
uno busca la ayuda y luego dice 00:38:52
ah pues puede ser esto 00:38:54
y luego ya lo prueba 00:38:56
luego lo prueba a ver si es verdad 00:38:58
que eso hace lo que tiene que hacer 00:39:00
entonces vamos a 00:39:02
uno haría su primera prueba 00:39:04
por ejemplo que es 00:39:06
aquí vamos a 00:39:08
como nuestro carácter separador 00:39:10
en este caso es 00:39:12
el punto y coma 00:39:14
es el carácter separador 00:39:16
vamos a ver 00:39:18
vamos a ver 00:39:25
no tengo nada que se llame apps por aquí 00:39:32
vamos a ver antes que nada 00:39:36
vale 00:39:38
a ver que estoy haciendo mal 00:39:42
si que si que hay algo que se llama apps 00:39:44
este 00:39:46
que soy tonta 00:39:48
estaba justo arriba y no lo veía 00:39:50
vale string 00:39:52
subcadenas 00:39:54
voy a llamar 00:39:56
espera no 00:39:58
va a quedar más claro si esto lo llamo apps 00:40:00
y esta es la cadena parámetro 00:40:02
esta es la cadena que le paso como parámetro 00:40:04
la cadena 00:40:06
vale y la voy a dividir con el split 00:40:08
la voy a dividir con el split 00:40:11
vale vamos a ver primero 00:40:13
vamos a recorrer 00:40:15
estas subcadenas 00:40:17
a ver si este método hace lo que queremos 00:40:19
vamos a verlo 00:40:21
fue 00:40:23
ay que torpe 00:40:25
fuera 00:40:27
lo quería hacer 00:40:29
vamos a 00:40:31
como esto es solamente para comprobar en plan rápido 00:40:33
vamos a mostrar 00:40:35
cada una de ellas 00:40:38
cada una de ellas 00:40:39
por string 00:40:41
app in 00:40:43
apps 00:40:45
vale vamos a mostrarlas 00:40:52
vamos a hacer esta primera prueba 00:40:54
hacer el split 00:40:56
en torno al punto y coma 00:40:58
hacer el split 00:41:00
vamos a ver que subcadenas 00:41:02
nos ha mostrado 00:41:04
a ver si es verdad que son los trocitos 00:41:06
yo estoy metiendo en un constructor directamente 00:41:07
entonces para ejecutar esto 00:41:09
tengo que instanciar un objeto 00:41:11
y probarlo 00:41:13
pero como estoy en mi fase de pruebas 00:41:15
que estoy probando haciendo cositas 00:41:17
me voy a hacer un main 00:41:19
en cualquier lado 00:41:21
me voy a hacer un main en cualquier parte 00:41:23
y ejecuto esa clase que tiene ese main 00:41:25
entonces quiero que 00:41:27
no os perdáis en esto lo que estoy haciendo 00:41:29
entonces 00:41:31
hasta aquí esta claro no 00:41:33
este es mi constructor 00:41:35
que es primero 00:41:37
dividir toda esta cadena gordota 00:41:39
en trozos separados por punto y coma 00:41:41
cuando tenga cada trozo 00:41:43
a su vez dividirlo por las comas 00:41:45
con ellos instanciar un objeto app 00:41:47
y mandarlo al 00:41:49
a la variable esta 00:41:51
este constructor tendría que hacer todo esto 00:41:53
pero bueno vamos por partes 00:41:55
vamos a ver si este split 00:41:57
por lo pronto hace lo que queremos 00:41:59
entonces yo lo he usado 00:42:01
lo voy a mostrar 00:42:03
y ahora simplemente para hacer una prueba rápida 00:42:05
voy a hacer un método main 00:42:07
voy a hacer un método main aquí mismo 00:42:09
aquí mismo 00:42:11
ya está en esta misma clase 00:42:13
luego ya lo borraré 00:42:15
aunque esta es una clase entidad 00:42:17
me voy a hacer un método main 00:42:19
aquí mismo porque no 00:42:21
yo puedo meter aquí un método main 00:42:23
y donde me dé la gana 00:42:25
me voy a hacer aquí un método main 00:42:30
y ahora 00:42:32
dentro de este main 00:42:34
que voy a hacer 00:42:35
instanciar un objeto app store 00:42:37
instanciar uno 00:42:39
porque al instanciarlo 00:42:41
llamará el constructor que está aquí arriba 00:42:43
lo llamará y me mostrará esto 00:42:45
pues venga vamos a instanciar 00:42:47
un objeto app store de estos 00:42:49
y ahora este constructor 00:42:58
hay que pasarle una cadena 00:43:00
con todas las 00:43:02
vamos a 00:43:03
copiar y pegar esto 00:43:05
a ver si este ejemplito por ejemplo 00:43:07
aquí 00:43:15
esto 00:43:17
vale 00:43:25
vale pues en esta clase 00:43:27
he metido un método main 00:43:29
que significa que ya he metido un método main 00:43:31
y esta clase automáticamente 00:43:33
la puede ejecutar la máquina virtual 00:43:35
claro porque tiene un método main 00:43:37
la máquina virtual puede ejecutar 00:43:39
cualquier clase que tenga un método main 00:43:41
vale pues cuando yo ejecute esta clase 00:43:43
que hará 00:43:45
instanciará un objeto app store 00:43:47
vale 00:43:49
la clase app store cuál es 00:43:51
esta misma en la que está el main 00:43:53
pero que más da, da igual 00:43:55
instancia un objeto app store 00:43:57
lo instancia 00:43:59
al instanciarlo 00:44:01
con todo esto 00:44:03
a ver si me muestra esto 00:44:05
vamos a probar 00:44:07
a ver si el split funciona 00:44:09
vale 00:44:11
entonces 00:44:13
de nuevo 00:44:15
no os liéis 00:44:17
no os liéis 00:44:19
y no os liaréis 00:44:21
si vais teniendo esto cada vez más claro 00:44:23
con que ya he metido aquí un main 00:44:25
de nuevo para probar 00:44:27
que problema hay que haya metido yo aquí un main 00:44:29
eso es un método más 00:44:31
vale 00:44:33
sus parámetros 00:44:35
su valor de retorno 00:44:37
que es nada 00:44:39
static 00:44:41
porque efectivamente lo que hace el main 00:44:43
el main no puede usar 00:44:45
ninguna propiedad de la clase 00:44:47
es un método estático 00:44:49
vale y no las usa 00:44:51
y public 00:44:53
para que lo pueda llamar 00:44:55
la máquina virtual 00:44:57
que está fuera del paquete 00:44:59
es un método más 00:45:01
esta clase la puede ejecutar 00:45:03
la máquina virtual 00:45:05
es decir 00:45:07
puede irse a este main 00:45:09
bueno pues ya está 00:45:11
pues vamos a ejecutar esta clase 00:45:13
se irá a este main 00:45:15
creará un objeto de esta clase 00:45:17
que está declarada en la misma 00:45:19
y que más da 00:45:21
creará un objeto de esta clase 00:45:23
llamará al constructor etc. 00:45:25
venga vamos a ejecutar esta entonces 00:45:27
ejecuto esta misma 00:45:29
y justo 00:45:31
me da un montón de cadenas 00:45:33
que son la separación 00:45:35
el splitting 00:45:37
el splitting de la cadena 00:45:40
vale 00:45:42
ala pues ya está 00:45:45
la primera parte ya la tenemos 00:45:47
ahí el main por ahora no molesta 00:45:51
por si quiero seguir haciendo pruebas 00:45:53
lo puedo dejar 00:45:55
pero luego cuando yo la aplicación 00:45:57
ya haya pasado yo la fase de pruebas 00:45:59
y de todo 00:46:01
a la entidad a Pestor 00:46:03
y no tiene ahí ningún main 00:46:05
la que se va a ejecutar es otra 00:46:07
vale pero bueno he puesto ahí ese main 00:46:09
para hacer mis pruebas 00:46:11
bueno pues entonces 00:46:13
nos volvemos al constructor 00:46:15
ahora 00:46:17
ahora que ya conocemos 00:46:19
como funciona el método split 00:46:21
ahora ya que habría que hacer 00:46:23
pues ir uno por uno 00:46:25
hacerle a su vez split 00:46:27
pero ahora con la coma 00:46:29
usar esos parámetros 00:46:31
con esos objetos 00:46:33
ir construyendo 00:46:35
este array 00:46:37
para guardarlo aquí 00:46:39
eso es lo que tiene que terminar 00:46:41
de hacer el constructor 00:46:43
venga pues continuadlo 00:46:45
a ver 00:46:47
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
28 de enero de 2024 - 18:54
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
46′ 46″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
216.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid