Saltar navegación

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

Clase 12-03-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 3 de abril de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues a partir de la idea, de la idea de gestionar un conjunto de discos, ¿vale? Pues, bueno, pues mi colección de, ¿vale? Entonces, la discoteca tiene una temática. 00:00:02
Tienes que crear 00:00:35
Claro, porque Remusol necesita una colección 00:00:44
Entonces tienes que pasarle una colección 00:00:46
Que hayas creado previamente 00:00:48
Bueno, pues entonces 00:00:49
String temática 00:00:52
Y ahora vamos a hacer que la discoteca tenga 00:00:54
Una lista de discos 00:01:04
¿Vale? 00:01:07
Pero discos 00:01:08
Que sea una interfaz 00:01:10
Porque como podemos tener varios tipos de discos 00:01:11
Podemos tener, vamos a inventarnos 00:01:13
Yo que sé, cualquier chorrada 00:01:15
Pues 00:01:16
Es que solo se me ocurre vinilo 00:01:17
O CD 00:01:26
Y habría que poner 00:01:28
Características, venga 00:01:30
Aunque salga cosarra, vamos a hacerlo así 00:01:32
¿Vale? O sea 00:01:34
La discoteca se caracteriza por la temática 00:01:35
Esta es sobre rock, vale 00:01:38
Ya está, mi temática es sobre rock 00:01:40
y tengo un conjunto de discos en ella 00:01:42
que voy a gestionar 00:01:44
que son de diferentes tipos 00:01:45
pero yo me voy a crear una interfaz 00:01:48
disco, una interfaz disco 00:01:50
y lo que tenga 00:01:53
en esa discoteca van a ser 00:01:55
discos, del tipo que sea, no lo sé 00:01:56
y ahora ya pues podemos 00:01:59
hacer aquí un constructor 00:02:03
con los parámetros 00:02:05
bueno, un gettyset 00:02:13
perdón 00:02:15
y un constructor 00:02:16
y un constructor sin parámetros 00:02:19
vale, y list 00:02:30
lo podemos importar de java útil 00:02:40
bueno, no me... 00:02:42
luego lo importamos cuando tengamos disco hecho 00:02:45
vale, entonces, ahora esta 00:02:46
aplicación se amplía 00:02:48
porque ahora ya discos 00:02:51
decidimos que podemos tener varios 00:02:52
tipos de discos y cada uno de ellos funciona 00:02:54
de una manera distinta, entonces hacer 00:02:56
una única clase disco 00:02:58
que recoja todo 00:03:00
pues a lo mejor embarbulla la aplicación 00:03:02
entonces decidimos, no, mejor tengo 00:03:04
dos clases, para dos tipos de discos distintos 00:03:07
y dejo que disco sea 00:03:09
la interfaz que la implementan 00:03:11
y ya está, pues por ejemplo 00:03:12
lo estoy haciendo sobre la marcha 00:03:14
para ver situaciones que nos van dando 00:03:16
vale, pero antes que lo entendamos 00:03:18
bueno, pues en ese caso disco sería una interfaz 00:03:20
y entonces 00:03:22
todos mis discos van a ser 00:03:24
implementaciones concretas de esta interfaz 00:03:26
pero algunos serán 00:03:28
discos de vinilo y otros de eso 00:03:30
como se quiera ver 00:03:32
Bueno, pues entonces vamos a crear esa interfaz disco 00:03:33
Bueno, y aquí 00:03:36
Aquí 00:03:47
¿Qué propiedades comunes van a tener? 00:03:49
No, perdón, es una interfaz 00:03:53
Aquí no hay propiedades, olvidadlo 00:03:54
Vale, entonces aquí podríamos decir 00:03:55
A ver, ¿qué funcionalidades queremos asociar 00:03:58
A los discos? 00:04:00
A todos ellos, sean de vinilo o sean de CD 00:04:01
Me da lo mismo 00:04:04
Pues por ejemplo 00:04:04
Todos ellos nos vamos a querer a lo mejor reproducir 00:04:06
Por ejemplo, ¿no? 00:04:09
pues vamos a suponer que hacemos un método 00:04:11
que se llama 00:04:13
reproducir 00:04:16
vale, me da igual que la aplicación 00:04:18
tenga mucho sentido o no lo tenga 00:04:24
ahora mismo lo que queremos es 00:04:25
practicar con el funcionamiento 00:04:27
de interfaces, colecciones, todo eso 00:04:30
una interfaz, pues método abstracto 00:04:32
vale, no hace falta que ponga public 00:04:37
porque por defecto todas las interfaces 00:04:40
sus métodos son public 00:04:42
vale 00:04:44
Podría dar una implementación por defecto 00:04:44
Hay cosas de interfaces 00:04:48
Que no hemos visto 00:04:50
Para no embarullar 00:04:51
Ya saldrán, ya irán saliendo 00:04:53
Para nosotros 00:04:55
Ahora mismo una interfaz es una colección 00:04:57
De métodos vacíos 00:04:59
Que luego ya las clases que los implementen 00:05:01
Decidirán cómo lo hacen 00:05:03
Y luego además puede haber 00:05:05
Constantes ahí 00:05:07
Porque si hay información interesante 00:05:09
Relevante para todos los discos 00:05:11
para todos, entonces puedo meter 00:05:13
ahí una constante a lo mejor, pero si no 00:05:15
necesito eso, pues no lo pongo 00:05:17
¿vale? ¿algún otro método que se le ocurra 00:05:19
a alguien que puedan 00:05:21
alguna otra funcionalidad 00:05:22
asociada a todos los discos? bueno 00:05:25
vamos a dejar una y ya está, como siempre lo mismo 00:05:27
¿vale? pues entonces 00:05:29
disco ya lo 00:05:31
tenemos, ya ponemos aquí importar list 00:05:33
entonces aquí 00:05:35
ya sí que no puedo hacer 00:05:38
esa protección 00:05:41
entre comillas que hacíamos a veces 00:05:43
oye, no pasa nada 00:05:45
vamos ya directamente a inicializar 00:05:46
esta propiedad, a inicializarla 00:05:49
creando una lista vacía 00:05:51
y así cuando 00:05:52
se crea un objeto discoteca 00:05:55
inicialmente no tiene discos, a menos que 00:05:56
luego yo se los vaya metiendo en el set o lo que sea 00:05:59
pero al menos esto no es nul 00:06:01
entonces eso 00:06:03
siempre es un protege 00:06:05
porque si alguien usa esa clase 00:06:06
y de partida se pone a meter aquí 00:06:09
y esto es null inicialmente 00:06:11
le va a ser null pointer exception 00:06:14
entonces recordad que decíamos 00:06:15
bueno, no es mala práctica 00:06:17
si yo tengo una propiedad que es una colección 00:06:18
en una clase, aprovechar y dejarla 00:06:21
instanciada 00:06:24
y me aseguro 00:06:25
uy, perdón 00:06:27
¿vale? y me aseguro 00:06:28
de que no me va a seguir el null pointer exception 00:06:42
¿vale? 00:06:43
lo único es que insisto 00:06:48
Aquí uno ya se está comprometiendo 00:06:49
A la implementación 00:06:53
No pasa nada, luego uno puede usar 00:06:54
Esta clase y sobreescribir 00:06:56
Discos con otra colección, si le interesa 00:06:59
¿Vale? Sobreescribirla 00:07:01
Bueno, pues esto es simplemente 00:07:02
De cara a, oye 00:07:05
Que de partida no sea nul 00:07:06
No vaya a ser que alguien me use mal, no verifique 00:07:08
Que esto no existe 00:07:10
Se ponga a hacer un add 00:07:12
¿Vale? Bueno 00:07:13
¿Vale? Pues entonces 00:07:15
Ahora 00:07:18
los discos 00:07:19
aquí es donde hemos decidido, nos hemos dado cuenta 00:07:21
que hay dos tipos de discos 00:07:23
pues entonces me hago una interfaz que unifique 00:07:25
lo común, en este caso lo común 00:07:28
se ha quedado muy escasito, se ha quedado en reproducir 00:07:30
pero bueno, unifica 00:07:32
lo común y ahora yo me hago ya 00:07:34
dos 00:07:35
implementaciones de esta interfaz 00:07:37
pues entonces 00:07:39
tengo 00:07:43
vinilo que implementa 00:07:45
disco, entonces al implementar 00:07:57
disco tiene que obligatoriamente 00:07:59
añadir 00:08:01
implementación de este método 00:08:07
que habría que decidirla, claro 00:08:09
cómo se reproduce el vinilo 00:08:12
por lo pronto vamos a caracterizar sus propiedades 00:08:14
pues las propiedades del vinilo 00:08:17
que sean, pues por ejemplo 00:08:19
el título 00:08:21
y la colección 00:08:21
de algo que lo pueda 00:08:30
distinguir de un CD que solo tenga un vinilo 00:08:32
que no tenga un CD 00:08:34
vosotros 00:08:35
claro 00:08:38
vosotros un vinilo 00:08:38
no sabéis ni lo que es 00:08:39
eso que adornan 00:08:40
las habitaciones infantiles 00:08:41
¿no? 00:08:42
digamos 00:08:43
¿eh? 00:08:43
hombre 00:08:47
los frikis de la música 00:08:47
lo siguen comprando 00:08:48
bueno 00:08:49
pues una cosa 00:08:52
que puede caracterizar 00:08:53
a los vinilos 00:08:54
que no caracterizan 00:08:55
a los CDs 00:08:55
puede ser el radio 00:08:56
porque los había pequeñitos 00:08:57
y grandes 00:08:58
¿no? 00:08:58
entonces 00:09:02
es por poner una propiedad 00:09:02
que tenga sentido 00:09:03
que esté aquí 00:09:04
y que no esté en el otro sitio 00:09:05
Venga, pues ala, el radio 00:09:06
Es que ni siquiera sé si se llamaba radio 00:09:09
¿Cómo se llamaba eso? 00:09:13
Eran de 45 y de 33 00:09:14
Ah, no, eso eran los disquetes 00:09:16
No, los disquetes eran de 5 y medio y 3 y cuarto 00:09:17
No, de 3 y medio y 5 y cuarto 00:09:21
Y los vinilos eran de 45 y de 33 revoluciones 00:09:23
Vale 00:09:26
Claro, los pequeñitos tenían que ir a 45 revoluciones 00:09:27
Y los grandes a 30 00:09:30
Bueno, da igual 00:09:31
Número de revoluciones por minuto 00:09:32
Esto es lo que caracteriza 00:09:36
El vinilo, que esto en un CD no tiene sentido 00:09:38
Obviamente 00:09:40
Vale, y ahora 00:09:41
La colección de 00:09:43
Número de revoluciones por minuto 00:09:45
Venga, estamos a dejarlo así, sin nada más 00:09:52
Ya está 00:09:54
Pues reproducir 00:09:54
Reproducir el vinilo 00:09:57
Pues vamos a hacer que sea 00:09:59
mostrar un mensajito reproduciendo 00:10:01
este, ya está 00:10:07
y aquí ponemos rápidamente los get y los set 00:10:12
y un constructor sin parámetros 00:10:16
para ir rápidos 00:10:25
no le ponemos constructores, con lo cual se queda uno sin parámetros 00:10:29
y luego ya podemos fijar con get y set y ya está 00:10:32
vale, y ahora vamos a hacer el otro 00:10:35
el cd, pues el cd también 00:10:37
implementadisco 00:10:53
implementadisco 00:10:57
y aquí sus propiedades van a ser 00:11:00
también el título 00:11:01
el título es común en ambas 00:11:03
pero no lo hemos podido poner en la interfaz 00:11:09
porque la interfaz no admite propiedades 00:11:11
si hubiéramos hecho otro diseño con una clase abstracta 00:11:13
pues entonces sí 00:11:15
podríamos haber puesto título en la clase abstracta 00:11:17
pero como es una interfaz 00:11:19
ahí no puede haber propiedades 00:11:21
y aquí le vamos a poner que el cd se caracteriza 00:11:22
por un conjunto de pistas 00:11:25
de pistas 00:11:27
y va a ser un conjunto 00:11:29
con lo cual no van a tener posición 00:11:42
sino que hay que seleccionarlas por el nombre 00:11:44
de la pista 00:11:47
por el nombre, vale 00:11:48
un conjunto de pistas, va a tener el cd 00:11:50
vale, luego 00:11:52
hacemos este método, vamos a hacerle los get y los set 00:12:12
para que 00:12:15
para quitarlos de en medio 00:12:17
cuanto antes, los get y set de esto 00:12:21
sin constructor, constructor sin parámetros 00:12:23
vale, importamos set 00:12:33
no me deja todavía hasta que no 00:12:34
bueno, entonces 00:12:37
pista es otra clase a propósito 00:12:38
es otra clase que pista va a tener 00:12:41
dos propiedades 00:12:43
el título y la duración 00:12:44
y ya está, pues vamos a crear 00:12:46
la clase pista 00:12:49
con el título de la pista 00:12:49
y la duración 00:12:56
get y set 00:13:03
bueno, a ver, pista 00:13:09
Pista no es superclase 00:13:17
Ni subclase 00:13:20
No, pero pista no hereda de CD 00:13:21
O sea, pista está en CD 00:13:24
O sea, un CD 00:13:26
Tiene pistas dentro 00:13:28
Pero eso no es heredar, eso es composición 00:13:29
O sea, esa relación está aquí ya 00:13:32
Es decir, un CD 00:13:34
Tiene pistas dentro 00:13:35
O sea, hay una relación que es 00:13:37
Una clase contiene dentro la otra 00:13:39
Esa relación de composición 00:13:42
Y una es heredar, que es 00:13:43
Una clase es la otra 00:13:45
Entonces la relación de herencia sería 00:13:47
Si yo puedo decir 00:13:49
Una pista es un CD 00:13:50
No, una pista no es un CD 00:13:52
Una pista está en un CD 00:13:54
Entonces cuando tú tienes dos entidades 00:13:56
Se puede relacionar como 00:13:58
Esta es esta 00:13:59
O esta está en esta 00:14:00
Si tú puedes decir 00:14:02
Esta es esta 00:14:03
Una hereda de la otra 00:14:05
¿Perdón? 00:14:06
Efectivamente 00:14:12
entonces una pista está en un CD 00:14:13
pero una pista no es un CD 00:14:16
entonces no puedes hacer pista 00:14:17
extens CD 00:14:19
esa relación será que dentro 00:14:20
de CD, dentro, aparece 00:14:23
esto, dentro, que es la relación 00:14:25
de composición, en realidad 00:14:27
esto se llama composición, un CD 00:14:29
está compuesto de pistas 00:14:31
está compuesto de pistas 00:14:33
vale, pues ya tenemos 00:14:34
nuestra 00:14:37
pista con duración y 00:14:38
título y ya está 00:14:41
y el cd que contiene pistas 00:14:42
y tengo que importar 00:14:46
set 00:14:48
y poner esto bien, claro 00:14:49
vale, reproducir 00:14:52
pues el método reproducir de cd va a cambiar 00:14:57
un poco, porque ahora el método 00:14:59
reproducir, en un vinilo 00:15:01
hemos asumido que cuando tú le das a reproducir 00:15:03
¡pam! reproduce 00:15:06
porque no va a haber ningún humano ahí 00:15:07
moviendo la agujita 00:15:09
hemos querido asumir eso, entonces tú le das a reproducir 00:15:11
y es, está reproduciendo patatín 00:15:13
vale, pero aquí 00:15:15
reproducir 00:15:18
vamos a hacerlo que solicite una pista 00:15:19
vale 00:15:22
la localice 00:15:24
y te diga voy a reproducir 00:15:25
pista con la duración tal 00:15:28
y deje el sistema 00:15:30
ahí parado 00:15:32
todos los segundos que dure la pista 00:15:34
por ejemplo, para cambiar 00:15:36
vale, pues entonces este método de reproducir 00:15:37
solicita un nombre de pista 00:15:40
y deja ahí 00:15:41
Nuestro programa 00:15:44
Parado 00:15:47
Todo el tiempo que dura la pista 00:15:48
Es nuestra forma de emular 00:15:50
Que está reproduciendo una pista 00:15:53
Vale, pues entonces aquí tenemos que 00:15:54
Pedir una pista 00:15:57
Localizarla en el set 00:15:58
Para sacar de ella 00:16:01
Su duración 00:16:03
Vale 00:16:05
Bueno, pues entonces 00:16:08
Bueno, tengo que importar haset 00:16:10
Pues nada, este reproducir pista 00:16:12
Va a ser 00:16:17
Título de pista 00:16:18
Dime el título de pista que quieres 00:16:21
Pues leemos la pista 00:16:23
Voy a meter 00:16:28
La otra clase 00:16:30
Ah, que ya la tenía, vale 00:16:31
Claro, que estoy en el mismo proyecto 00:16:35
Vale, pues el título mío de pista 00:16:37
Lo leo 00:16:43
Y ahora ya tengo 00:16:46
El dato de entrada 00:16:51
El dato de entrada no lo he puesto que lo reciba por parámetro 00:16:52
Porque reproducir es el método 00:16:55
que implementa la 00:16:59
interfaz, entonces 00:17:00
la cabecita tiene que ser idéntica, clavada 00:17:02
yo me podría hacer otro método aparte 00:17:04
me lo podría hacer, pero este le tengo 00:17:07
que implementar sí o sí 00:17:09
el que está en la interfaz, y la interfaz me dice 00:17:10
oye, implementa un método reproducir sin 00:17:13
parámetros, pues lo tengo que hacer así 00:17:15
bueno, pues nada, título de pista 00:17:16
y ahora que tenemos que hacer aquí, pues hemos dicho 00:17:18
vamos a buscar en las pistas 00:17:20
y cuando 00:17:22
la encontremos, pues ya está 00:17:24
que reproduzca, entonces aquí 00:17:26
Podemos hacer varias cosas 00:17:28
Por ejemplo, podríamos hacer 00:17:29
Sí, pista ya la he hecho para que tenga título y duración 00:17:31
Una pista de un CD 00:17:40
Se caracteriza por su título y su duración 00:17:41
Nada más, ya está 00:17:43
Estoy obviando las posiciones 00:17:44
En un CD sí que tiene posiciones 00:17:46
La 1, la 2, la 3, pero las he obviado 00:17:49
Para usar un set precisamente 00:17:51
Bueno, pues entonces 00:17:52
Vamos a imaginarnos 00:17:56
Que yo ahora quisiera ver primero de todos 00:17:59
Imaginaos que yo quiero comprobar 00:18:01
que esta pista está en el CD 00:18:03
lo primero de todos 00:18:06
la puedo recorrer y comprobarlo 00:18:08
o también podría hacer esto 00:18:12
para eso tenemos un método 00:18:14
contains, si yo lo quiero hacer con contains 00:18:16
porque 00:18:18
imaginaos que yo quiero ver 00:18:18
la colección 00:18:30
de pistas que es esta 00:18:35
contiene la lista 00:18:36
imaginaos que yo quiero ver si la colección de pistas 00:18:38
contiene esa pista, que quiero ver eso 00:18:41
con este método 00:18:43
para que en el caso de que no la contenga 00:18:44
por ejemplo, si no la contiene 00:18:47
pues yo quiero a lo mejor decir 00:18:48
no existe esa pista 00:18:53
¿vale? imaginaos que 00:18:56
yo empiezo haciendo esta parte de aquí 00:19:02
ahora os pregunto 00:19:04
¿aquí qué pongo? 00:19:05
para ver si esa pista está o no 00:19:08
¿qué pondría aquí? 00:19:10
el título de la pista 00:19:14
si yo pongo el título de la pista 00:19:15
claro 00:19:21
el compilador se ha quedado 00:19:23
tan ancho 00:19:25
pero llamemos que 00:19:26
me salga un aviso 00:19:29
ese aviso a que se corresponde 00:19:30
ese aviso se corresponde 00:19:36
a que pistas es una colección 00:19:38
no es de cadenas 00:19:40
no es de títulos 00:19:41
pistas es una colección de objetos pista 00:19:43
entonces al contains le tengo que pasar 00:19:46
un objeto pista 00:19:48
A Contains hay que pasarle un objeto pista 00:19:49
Para que él me diga si está en esta colección 00:19:52
Y yo le he pasado una cadena 00:19:54
Entonces él me dice, tú pásame lo que quieras 00:19:55
Pero es que yo te voy a decir que no 00:19:58
Porque una cadena no va a estar 00:19:59
En un conjunto de objetos pista 00:20:01
Tú pásame una pista y ya está 00:20:04
Con lo cual una cadena 00:20:06
No le podemos pasar 00:20:07
Vale, pues entonces, ¿qué le pasamos? 00:20:09
Le tenemos que pasar un objeto pista 00:20:11
¿Qué le pasaríais? 00:20:12
Con el título, pero sea creando un igual 00:20:16
Y eso es lo difícil 00:20:18
Efectivamente 00:20:19
aquí el problema que nos falta es 00:20:21
vale, yo tengo que ver si esta 00:20:23
pista está, para la cual 00:20:25
solo dejo el título, entonces yo automáticamente 00:20:27
me hace volver a algo 00:20:29
que hemos pasado por alto cuando he 00:20:31
hecho estas clases y es, vamos a ver 00:20:33
aquí hay algo que identifique 00:20:35
de forma única las pistas 00:20:37
porque si lo hay 00:20:39
dejémoslo ya 00:20:40
dejémoslo ya reflejado 00:20:42
aquí, pues sí 00:20:45
cada pista se caracteriza por un título 00:20:47
la duración no 00:20:49
porque puede haber diferentes 00:20:52
pistas del CD con la misma duración 00:20:54
con la misma, luego duración no caracteriza 00:20:56
de forma única las pistas 00:20:58
pero título sí 00:20:59
entonces conviene 00:21:01
que yo incorpore el método 00:21:04
equals para que me diga, oye 00:21:05
pistas de igual título son iguales 00:21:07
¿vale? eso para empezar 00:21:10
bueno, pues entonces aquí 00:21:11
yo me puedo hacer 00:21:13
mi equals con título 00:21:19
vale 00:21:22
yo tengo entonces aquí ya hecho mi criterio 00:21:25
de igualdad que me dice 00:21:30
si una pista tiene el mismo título 00:21:31
que otra, a todos los efectos 00:21:34
para la aplicación son la misma 00:21:36
bueno 00:21:38
entonces ahora vuelvo aquí 00:21:43
ahora vuelvo a 00:21:45
donde estaba 00:21:48
en CD 00:21:49
si aquí estaba 00:21:53
aquí, vale 00:21:55
entonces aquí hemos dicho 00:21:56
vamos a pasarle un objeto pista con ese título 00:21:59
un objeto pista con ese título 00:22:01
y entonces 00:22:04
con taste me va a decir a ver si hay 00:22:06
alguno igual que 00:22:08
este objeto pista con ese título en la colección 00:22:10
entonces como 00:22:12
la igualdad viene por el título 00:22:14
me da igual que este objeto pista no tenga 00:22:16
duración puesta o tenga la duración que a mi me dé la gana 00:22:18
vale 00:22:20
entonces 00:22:22
como yo no he puesto constructores 00:22:23
lo tengo que hacer con getDiset 00:22:26
pues vamos a 00:22:28
hacer una pista por aquí 00:22:30
y ahora 00:22:32
p.set título 00:22:34
este, vale 00:22:37
esto ya tiene más sentido porque 00:22:44
yo le paso una pista con un título y 00:22:46
contains ya sabemos que lo que hace es 00:22:47
buscar si hay alguna 00:22:49
pista en este conjunto 00:22:51
igual a esta 00:22:53
y para ver si es igual 00:22:54
el criterio de igualdad que hemos fijado es el título 00:22:57
por eso solo he fijado el título 00:23:00
la duración me da igual porque la va a ignorar 00:23:01
el contains va a ignorar la dirección 00:23:03
vale, entonces con esto 00:23:05
ya lo tendríamos 00:23:08
ya lo encontraría, con test ya funcionaría 00:23:09
aquí lo que no se nos puede 00:23:12
olvidar es, oye, que tipo 00:23:17
de colección es esta 00:23:19
no tienes que poner 00:23:20
pero si ya la tengo 00:23:21
claro, pero es que yo no tengo 00:23:26
como no he hecho constructor con parámetros 00:23:32
por eso lo he hecho fuera, por vaguería 00:23:34
no he hecho constructor, pero vamos, es igual 00:23:36
es lo mismo, vale, entonces 00:23:38
aquí, claro 00:23:40
que no se nos tiene que olvidar nunca 00:23:43
el pensar, a ver, espérate 00:23:45
¿con qué tipo 00:23:47
de colección estás trabajando? 00:23:49
porque en función del tipo de colección 00:23:51
con el que estás trabajando 00:23:53
los métodos de esa colección 00:23:54
verifican la igualdad de una manera 00:23:57
o de otra 00:24:01
las listas, sea linked list o array list 00:24:01
ya sabemos que verifican la igualdad 00:24:04
con el equals y ya está 00:24:07
pero esto no es una lista 00:24:08
pistas no es una lista 00:24:11
pistas es un 00:24:13
haset 00:24:15
¿no? 00:24:15
luego como pistas es un haset 00:24:18
los métodos de pistas 00:24:20
el contains, el remove, etc 00:24:23
cuando tienen que ver si un objeto 00:24:25
es igual a otro 00:24:27
no usan solo el equals, ¿qué más usan? 00:24:27
el hashCode 00:24:33
usaban primero el Haskell y luego el Equals 00:24:33
y yo en pista 00:24:36
no he hecho el Haskell, he hecho el Equals solo 00:24:38
entonces si esto fuera 00:24:40
una lista, si esto fuera 00:24:42
un list, ya está, no tengo más que hacer 00:24:44
si esto fuera un list, no tengo más que hacer 00:24:46
porque el 00:24:48
contains de aquí 00:24:50
va a ir aplicando el Equals 00:24:52
de este con todos y cada 00:24:54
uno de los de aquí, va a ir aplicando el Equals 00:24:56
en cuanto encuentra una que el Equals le da true 00:24:58
ya está, magnífico 00:25:00
Pero pistas no son list, pistas es un hash set, con lo cual el contains de ese hash set, donde estoy, el contains de hash set es diferente del contains de list, es distinto, este es el contains de hash set, ¿por qué eso es un hash set? 00:25:02
pues el context de hashSet lo que hace es 00:25:23
coge este objeto y va 00:25:25
uno por uno haciendo hashCode 00:25:27
igual, hashCode equals, porque así es como vimos que 00:25:29
funcionaba, así es como vimos que funcionaba 00:25:31
y cuando encuentra uno 00:25:33
en el cual la secuencia de 00:25:35
hashCode equals le da true, entonces 00:25:37
dice, ah pues está, claro pero 00:25:39
entonces tengo que hacer el hashCode 00:25:41
porque si no lo hago, ya sabéis que esto que 00:25:42
le pasa, entonces el hashCode solo da true 00:25:45
si son el mismo objeto 00:25:47
la misma dirección de memoria, uno encima del otro 00:25:48
¿vale? 00:25:50
Claro, pues entonces aquí nunca me va a encontrar esta pista, aquí nunca, aunque el título sea igual, 00:25:53
aunque el título sea igual, nunca me la va a encontrar si yo no pongo aquí el hashCode, si no lo pongo. 00:25:59
Ahora ya sí, ¿vale? Ahora ya sí, ¿vale? 00:26:05
Entonces, repitiendo, como este objeto es un hashSet, la clase a la que van a pertenecer los objetos que la forman, 00:26:16
La clase a la que van a pertenecer tienen que ofrecer 00:26:28
cómo van a implementar el hashCode y el equals, los dos. 00:26:32
Porque la clase hashSet usa los dos. 00:26:36
¿Y cómo lo van a implementar? 00:26:41
Pues yo decido en función de qué parámetro, de qué propiedad les interesa. 00:26:42
Y va a ser de la propiedad o las propiedades que lo identifiquen de forma única. 00:26:47
A ver, podríamos haber decidido que a cada pista del CD se caracterice por ambas. 00:26:52
Es decir, pistas del mismo título pueden ser distintas si su duración es distinta 00:26:58
Podría ser otras situaciones, que eso ya depende de cuál sea mi situación real 00:27:06
Yo tengo que describir mi situación real 00:27:10
Pues tu situación real es que pistas del mismo nombre son la misma 00:27:12
Pues ya está, esto es lo único que forma parte del jasco de equals 00:27:16
Pero tu situación podría ser, no, no, no 00:27:20
Dos pistas pueden llamarse igual, pero son distintas si la duración es distinta 00:27:22
si tu situación es esa 00:27:26
que eso depende de la situación real 00:27:28
que tienes que analizar, claro, situación es esa 00:27:31
pues entonces el 00:27:33
jasco de equals será distinto 00:27:34
el jasco de equals implicará a los dos 00:27:36
y lo generaremos de forma distinta, claro 00:27:38
implicando a los dos 00:27:40
y si a uno se le olvida 00:27:41
y no hace jasco de equals 00:27:44
y no los pone ahí, pues ¿qué está pasando? 00:27:47
lo que ya hemos hecho mil veces 00:27:49
¿significa eso que la clase pista no tiene 00:27:50
jasco de equals? claro que lo tiene 00:27:52
tiene el heredado de object 00:27:54
porque para eso pista hereda de object 00:27:55
como todas las clases del mundo 00:27:58
entonces si yo no lo sobrescribo 00:27:59
si no lo sobrescribo 00:28:01
usa el de object 00:28:03
y el hascode de equals 00:28:05
de object 00:28:07
y el equals de object ya sabemos lo que hace 00:28:08
solamente detecta igualdad 00:28:11
si los objetos 00:28:14
están apuntados por la misma 00:28:15
y están encima del otro 00:28:17
es decir, nunca van a detectar 00:28:19
igualdad dos pistas del mismo título 00:28:22
si no son 00:28:24
un objeto apuntado por la misma 00:28:26
dirección de memoria 00:28:28
es decir, yo aquí le puedo pasar 00:28:29
una pista con el mismo 00:28:31
título y la misma duración que cualquiera 00:28:34
de estas, una que me he creado con 00:28:36
mismo título, misma duración 00:28:38
y el context nunca me va a dar plus 00:28:39
porque este objeto no va a tener 00:28:42
la misma dirección de memoria que esto, no va a tenerlo 00:28:44
y el jasco de equals de object 00:28:46
exigen que 00:28:48
la dirección de memoria sea la misma 00:28:50
para dar igual 00:28:52
Luego para que la aplicación funcione 00:28:52
Con sentido y sus resultados tengan sentido 00:28:56
Sus resultados tengan sentido 00:28:58
Pues tengo que decidir esta implementación 00:28:59
Tengo que decidirla 00:29:02
Bueno pues entonces 00:29:03
Estábamos con nuestro método reproducir 00:29:07
Que pedía una pista y lo primero que hemos hecho es 00:29:10
Ver si no la contiene 00:29:13
No existe 00:29:15
Y podríamos aprovechar ya y salir 00:29:16
Del 00:29:19
Método con el retun 00:29:24
¿verdad? podríamos aprovechar 00:29:28
ya salir con el return 00:29:30
y ahora en el caso 00:29:31
de que la contenga 00:29:34
pues vamos a 00:29:35
parar, esto es por hacer la tontería 00:29:37
parar el 00:29:40
programa, dejarlo detenido 00:29:42
el tiempo que dure 00:29:43
la pista 00:29:44
y uno puede parar siempre 00:29:47
un programa 00:29:49
si le da la gana 00:29:51
dejarlo ahí pausado, así 00:29:53
con esto 00:29:55
pone aquí los milisegundos 00:29:57
por ejemplo 00:30:00
esto dejaría parado 00:30:02
lo que pasa es que tengo que propagar la excepción 00:30:03
y ya está 00:30:06
y entonces 00:30:07
no, porque esto tendría que cambiar la interfaz 00:30:10
nada, esto solamente 00:30:14
pues porque haga algo distinto 00:30:22
esta sentencia 00:30:23
sleep lo que hace es 00:30:26
deja el programa pausado 00:30:27
ahí parado, tantos milisegundos 00:30:29
como tú le digas 00:30:32
entonces 00:30:33
vale, en nuestro caso 00:30:35
serán los milisegundos que 00:30:37
dure la pista 00:30:39
bueno, pues entonces, ahora 00:30:40
¿qué tendríamos que 00:30:43
hacer ahora? bueno, la pista existe 00:30:46
ahora ya tenemos que dejar el programa 00:30:47
parado con esta sentencia 00:30:49
tantos milisegundos 00:30:51
como me diga la duración de la pista 00:30:53
bueno, pues ¿qué es lo siguiente que haríais ahora? 00:30:55
en este método 00:30:58
ya sabemos que 00:31:00
la pista existe 00:31:01
hay que localizar la duración de esa pista 00:31:02
¿no? pues que es lo siguiente que haríamos 00:31:05
¿eh? 00:31:06
que es lo siguiente que haríamos ahora ya 00:31:09
para completar este método 00:31:11
venga, conectaros, ¿en qué estáis pensando? 00:31:12
a ver, la pista 00:31:20
ya existe y ahora ya 00:31:21
tenemos que localizar la pista 00:31:23
para parar el programa todo el tiempo 00:31:25
que dure, bueno, pues que es lo siguiente que haríais 00:31:27
¿eh? 00:31:29
que es lo de try-catch 00:31:30
esto nada 00:31:32
olvídate, ya lo mencionamos cuando 00:31:34
hicimos la clase teclado, dijimos ya cuando 00:31:36
veamos excepciones 00:31:38
ya lo haremos, ¿vale? 00:31:40
que significa, intenta hacer esta sentencia 00:31:42
y si no lo consigues, haz esto 00:31:44
pero ya lo veremos en detalle cuando 00:31:45
lo que pasa es que para llamar a este 00:31:48
método tan tonto, que es un método que 00:31:50
deja el programa parado, es obligatorio 00:31:52
hacer el try card, por eso lo puse 00:31:54
pero olvidaos del try card 00:31:56
me da igual 00:31:59
ahora pregunto, ahora que es lo siguiente 00:31:59
que haríais, que programaríais 00:32:03
para conseguir esto que digo 00:32:04
que es encontrar la duración 00:32:06
de la pista para dejar parada 00:32:09
el programa 00:32:10
bueno, recorrer 00:32:12
la colección es lo que estoy esperando que me digáis 00:32:16
lo siguiente que haríais, recorrer la colección hasta encontrar 00:32:18
esa pista 00:32:20
te refieres para evitar 00:32:27
el content de arriba, claro 00:32:30
pero es que yo lo he separado por partes para revisar 00:32:32
el content arriba, vale 00:32:34
yo lo que me interesaba era 00:32:36
Con lo de arriba 00:32:37
Que os refrescaréis el contains 00:32:39
Y el hasset, el equals y todo eso 00:32:42
Vale, bueno pues ahora 00:32:44
Vamos a recorrer la colección 00:32:46
Vamos a recorrerla 00:32:47
Hasta encontrar la pista 00:32:49
Para cada pista p 00:32:51
En las pistas estas 00:32:54
Pues que podemos hacer 00:32:56
Pues si esta es la que tengo que reproducir 00:32:59
Si p.get 00:33:01
Título 00:33:04
Resulta que es 00:33:05
igual que la pista que estoy 00:33:08
buscando, pues ala, ya está 00:33:09
ya puedo 00:33:11
hacer esta sentencia de aquí 00:33:12
y hago esta sentencia, pasándole 00:33:15
¿qué? pues pasándole 00:33:21
p.getDuración 00:33:23
y listo 00:33:26
y ya está 00:33:28
esta llave cierra esto 00:33:29
y me 00:33:31
falta la llave del forEach 00:33:33
que 00:33:35
estaría ahí 00:33:37
y p es que ya la tengo 00:33:38
usada 00:33:40
y esto es pista 00:33:44
pista, ahí, vale 00:34:01
bueno, pues entonces 00:34:04
este método pide la pista 00:34:07
primero 00:34:11
mira a ver si está o no está 00:34:12
mira a ver si está o no está, si no está afuera 00:34:14
y luego ya si hemos llegado 00:34:16
a este punto es porque ya está 00:34:18
y cuando la encuentra 00:34:20
pues deja el programa parado lo que dure la pista 00:34:23
y se acabó, pero vamos 00:34:26
esto por poner algo 00:34:27
podríamos haber puesto reproduciendo pista 00:34:29
que dura no sé cuántos, me da igual 00:34:31
vale, pues ya tenemos el CD 00:34:33
y el vinilo con sus propiedades 00:34:43
implementando 00:34:45
reproducir cada uno de ellos 00:34:47
vale, vamos a hacer un main 00:34:49
que haga cosas con 00:34:54
estos discos, esto ya 00:34:57
no se parece en nada 00:34:58
vamos a hacer un main aquí 00:34:59
vale 00:35:08
y aquí como métodos para luego 00:35:37
llamar desde el mini y quedemos organizados 00:35:38
aquí nos podemos plantear 00:35:40
algunas funcionalidades que nos pueda interesar hacer 00:35:41
con esta estructura de clases 00:35:44
que ahora mismo son cinco 00:35:49
discoteca, disco, vinilo, CD y pista 00:35:52
son las cinco entidades de nuestro modelo de datos 00:35:54
discoteca que tiene un list de discos 00:35:57
la clase disco es una interfaz 00:36:00
que a su vez tiene un vinilo y CD 00:36:03
que se reproducen de forma distinta cada uno 00:36:04
y luego cd que a su vez tiene pistas 00:36:09
y cd para 00:36:11
reproducirla, para reproducirse 00:36:13
ha necesitado efectivamente acceder 00:36:16
a las pistas que tiene 00:36:18
y luego un main 00:36:19
que es el main que va a hacer cosas con estas cosas 00:36:21
vale, vamos a parar unos minutejos 00:36:23
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
3 de abril de 2024 - 18:33
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
36′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
178.64 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid