Saltar navegación

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

Clase 12-03-24 - 2 - 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.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a continuar con esto 00:00:00
Vale, pues vamos a hacer antes que nada 00:00:02
Un método simplemente 00:00:05
Para llenarlo de datos 00:00:07
De cualquier manera 00:00:08
Para poder llenar la discoteca 00:00:10
De cosas 00:00:13
Y poder trabajar con ella 00:00:14
Entonces, si nosotros tenemos aquí una discoteca mía 00:00:18
Esta de aquí 00:00:21
Ah, perdón 00:00:22
Venga, pues le ponemos aquí 00:00:23
Tenemos una 00:00:35
Vale 00:00:38
Entonces 00:00:39
Vamos a hacer un método 00:00:40
Para llenarla de datos 00:00:42
Simplemente 00:00:45
Vale 00:00:46
Un método simplemente para ponerle datos 00:01:13
Para luego poder trabajar con ella 00:01:15
Y así no tenemos que pedirlos por teclado 00:01:16
Que es un rollo 00:01:18
Entonces la discoteca tiene el título y la lista de discos 00:01:18
Pues venga 00:01:22
Vamos simplemente a 00:01:24
Le vamos a poner 00:01:25
Su temática 00:01:29
Pues su temática, cualquier cosa 00:01:35
Ya, le vamos a añadir unos cuantos 00:01:38
Discos y pistas 00:01:43
Y ya está, vale 00:01:45
Entonces 00:01:47
Vale, pues vamos a hacer un CD 00:01:47
Vamos a hacer un CD 00:02:02
Vale, esto es un CD 00:02:03
Vamos a hacer primero un CD 00:02:07
Pues a este CD de aquí 00:02:09
Como los Getty Set no los tengo en disco 00:02:11
Pues a este CD le vamos a 00:02:21
Pues es título o cualquier uno 00:02:27
Cualquier cosa 00:02:40
Y ya le vamos a añadir 00:02:41
Pistas 00:02:49
Voy a hacer un constructor con parámetro en pista 00:02:49
Para poder hacerlo más rápidamente 00:02:53
Venga, pues a este CD 00:02:54
Que se llama así 00:03:07
Le vamos a añadir a sus pistas una nueva pista que se llame pista 1 y dure 1000 00:03:08
Y le vamos a añadir otra pista 2 que dure 2000 00:03:27
Solo para tener datos de cara a probar 00:03:39
Y ahora este CD se lo pasamos a los discos 00:03:46
Le añadimos el CD1 00:03:57
Entonces este ad 00:04:00
Estamos añadiendo a un set 00:04:05
Y con este ad estamos añadiendo 00:04:07
A un list, a este de aquí 00:04:11
Y vamos a hacer un vinilo también 00:04:12
Que el vinilo 00:04:17
Pues tenga como título 00:04:30
Y revoluciones 00:04:31
Pues nada 00:04:38
Y ahora lo mismo 00:04:40
Le añadimos este 00:04:44
Bueno, pues nada, estamos trabajando añadiendo cosas a colecciones 00:04:46
No tiene mayor 00:05:01
creamos el 00:05:02
a este 00:05:04
objeto 00:05:06
vale, entonces de nuevo 00:05:07
no olvidéis con todo esto lo del paso 00:05:10
por valor y por referencia que veíamos 00:05:12
a principio de curso, estamos 00:05:14
pasando el parámetro por aquí 00:05:16
y luego yo lo 00:05:18
modifico y el método termina 00:05:20
entonces uno le podría entrar la 00:05:22
pregunta, oye 00:05:24
yo he modificado esto 00:05:26
en el parámetro 00:05:28
de toda la vida, cuando se pasa un parámetro 00:05:30
a un método, se pasa una copia 00:05:33
claro, se pasa una copia 00:05:35
pero es que esto es un objeto 00:05:37
entonces como esto es una variable 00:05:38
objeto, lo que esto es físicamente es una 00:05:40
dirección de memoria, entonces hemos pasado 00:05:42
la copia 00:05:45
de la dirección de memoria donde está esta discoteca 00:05:46
la copia, pero es 00:05:49
una copia de una dirección, entonces 00:05:51
es una copia de una dirección, con lo cual a través de la 00:05:52
copia de la dirección 00:05:54
estoy accediendo al mismo sitio 00:05:55
Entonces todos los cambios que yo estoy haciendo 00:05:59
En esta variable 00:06:01
Todos estos cambios 00:06:02
Se están haciendo en el objeto 00:06:04
Cuando este método ha terminado 00:06:06
Esta copia 00:06:09
De la dirección de memoria 00:06:11
Esta copia ha desaparecido 00:06:12
Pero lo que yo he modificado a través de la dirección de memoria 00:06:14
Se ha quedado 00:06:16
Bueno, pues no vayáis olvidando esas cosas 00:06:17
Vale, pues entonces llenar datos 00:06:22
Uno podría ya llenar datos así 00:06:23
Le pasamos este objeto y se acabó 00:06:25
¡Hala! Esta discoteca ya tiene datos 00:06:33
Vale 00:06:37
Bueno 00:06:37
Pues qué funcionalidades podemos hacer 00:06:39
Pues venga 00:06:42
Por ejemplo 00:06:43
Primera funcionalidad que vais a hacer ahora 00:06:46
A ver 00:06:49
Vamos a hacer una funcionalidad 00:06:50
Que sea 00:06:53
Devolver el 00:06:54
Con más pistas 00:07:01
No, vamos a incorporar más cosas 00:07:03
con más duración 00:07:10
vale, venga, os lo complico 00:07:12
ya de partida 00:07:26
private disco static 00:07:27
vale, pues 00:07:30
se le pasa un objeto discoteca 00:07:32
se le pasa un objeto discoteca 00:07:34
y tiene que devolver 00:07:36
el CD, de todos los CDs 00:07:37
que haya, si es que hay algunos, si no hay ningún CD 00:07:40
devolver a nul 00:07:42
pues tiene que devolver el CD 00:07:43
el CD 00:07:47
cuya suma de pistas 00:07:48
dure más 00:07:50
el que más dure en total, sumando la duración 00:07:52
de cada una de sus pistas 00:07:54
eso es lo que tiene que devolver, el valor de retorno 00:07:55
es disco, no pasa nada porque un CD 00:07:58
implementa disco, con lo cual 00:08:00
aunque el valor del objeto de retorno 00:08:02
va a ser un objeto CD 00:08:04
esto está aquí perfectamente puesto 00:08:05
pues venga 00:08:09
entonces aquí, ¿qué habrá que hacer? 00:08:14
pues es de nuevo el máximo de algo 00:08:15
¿el máximo de qué? 00:08:17
de todos los CDs que estén en los discos de aquí 00:08:19
entonces habrá que entrar en la colección 00:08:22
de discos de este 00:08:24
De todos ellos, sólo los que sean CD 00:08:25
Hacer la suma de sus pistas 00:08:28
Sólo de los que sean CD 00:08:30
Para eso tenemos el InstaSoft, etcétera 00:08:32
Sólo de los que sean CD 00:08:34
Sumar las pistas 00:08:35
Si supera el máximo, tengo nuevo máximo 00:08:37
Un poquito lo de siempre 00:08:39
Pero aplicado aquí a esta estructura 00:08:42
Entonces hay que recorrer 00:08:44
Tanto el list de discos 00:08:48
Que tiene este, como luego el set 00:08:49
De pistas para hacer la suma 00:08:51
Hay que hacer dos recorridos 00:08:54
Bueno, pues a ver 00:08:55
Venga, pues vamos 00:08:56
Perdón, que está pausado 00:09:06
Vale, pues aquí es lo de siempre 00:09:10
Siempre uno tiene que analizar bien 00:09:15
Qué tiene que hacer e ir 00:09:16
De lo grande a lo pequeño 00:09:18
Entonces aquí lo grande que es 00:09:20
Tengo que encontrar 00:09:22
Un disco, un objeto disco 00:09:24
Dentro de una colección de discos 00:09:27
que es el que más cumple algo 00:09:29
bueno, ese ya es un problema 00:09:31
que tenemos aislado 00:09:34
encontrar dentro de una colección de cosas 00:09:35
el que más cumple algo 00:09:37
ya es un problema que tenemos aislado 00:09:38
y que se mete de la misma manera 00:09:40
pues identificamos uno como 00:09:41
el que más lo cumple en ese momento 00:09:43
inicialmente 00:09:46
y luego ya empezamos a recorrer 00:09:47
todos los demás 00:09:50
y en cuanto encontramos 00:09:51
uno que lo supera lo actualizamos 00:09:54
y ya está 00:09:56
es el problema de siempre 00:09:57
bueno, esa es la idea general 00:09:59
es el problema que tenemos que resolver 00:10:01
y cómo lo resolvemos, siempre así 00:10:03
de partida 00:10:05
uno es el máximo hasta ese momento 00:10:07
recorro toda la colección 00:10:09
para cada uno, supera el máximo 00:10:11
actualiza máximo, el problema del máximo 00:10:13
de siempre, y si es del mínimo, pues al revés 00:10:15
bueno, pues aquí 00:10:17
ahora ya que tenemos claro lo que tenemos que hacer 00:10:19
empezamos a perfilar 00:10:21
acotar nuestro problema 00:10:24
¿Qué colección es la que hay que recorrer 00:10:25
Para ver cuál es el que más 00:10:29
Cumple algo? 00:10:30
Pues lo que hay que recorrer son los discos 00:10:32
De este, los discos de este 00:10:34
Bueno, los discos de este 00:10:36
¿Dónde están? Esto es una clase discoteca 00:10:38
Pues habrá que irse aquí 00:10:40
En una lista, vale, hay que recorrer 00:10:41
Los discos de este de aquí, que es una lista 00:10:44
Bueno, pues recorrer una lista 00:10:46
Sabemos hacerlo 00:10:48
¿Vale? Entonces en este caso 00:10:49
No vamos a eliminar nada de la lista 00:10:52
Solo vamos a consultar para cada disco 00:10:54
Cuánta duración tiene 00:10:56
Entonces podemos recorrer con un for 00:10:57
Y en este caso encima de índice 00:11:00
Porque es una lista 00:11:01
Bueno, pues en algún momento tendremos que hacer algo así 00:11:02
¿Vale? Vamos a recorrer esta lista 00:11:06
Vamos a recorrer esta lista 00:11:10
Para ver si cada uno de esos discos 00:11:20
Supera al de mayor duración en ese momento 00:11:23
Y si lo supera actualizo el máximo 00:11:26
¿Perdón? 00:11:29
también valdría 00:11:30
vale 00:11:33
vale, entonces 00:11:34
¿por qué he cogido este 00:11:36
a propósito? 00:11:38
porque como es el máximo 00:11:41
el máximo siempre lo solemos hacer 00:11:43
inicializo el máximo 00:11:45
iniciar al primero de todos 00:11:47
y luego recorro los demás 00:11:49
entonces con un for de índice 00:11:51
puedes partir desde el segundo 00:11:53
si te da la gana 00:11:55
con un for each 00:11:56
obligatoriamente el for each 00:11:57
te recorre toda la colección siempre 00:11:59
en un for each no puedes elegir pararte 00:12:01
en la mitad, a menos que hagas un break 00:12:03
claro 00:12:05
entonces por eso he puesto esta a propósito 00:12:06
vale, pues tenemos que hacer este recorrido 00:12:09
bueno, pues entonces inicialmente nuestro resultado 00:12:11
final va a ser el disco 00:12:14
que tiene la duración máxima 00:12:15
llamémoslo así, por ejemplo 00:12:20
pues vamos a hacer, venga, como esto es una lista 00:12:22
entonces como esto es una lista 00:12:24
y en una lista tiene sentido decir el primero 00:12:26
tiene sentido decir el primero 00:12:28
pues el cd de duración máxima 00:12:30
inicialmente que sea el primero 00:12:33
de todos, inicialmente el primero de todos 00:12:35
bueno, pues el primero de todos 00:12:37
es este, ¿vale? 00:12:39
bueno, sería más cómodo si hago 00:12:52
el getFirst directamente porque es un linked list 00:12:53
¿no? como es un linked list 00:12:55
puedo hacer, tiene este método 00:12:58
pero recordad que el array list 00:12:59
no lo tiene 00:13:01
el array list no, entonces bueno 00:13:02
¿vale? pero bueno, si nos olvidamos de que el linked list 00:13:05
te ofrece ese para simular lo de las colas 00:13:08
no sé qué, nos olvidamos de esto 00:13:10
no, yo quería 00:13:12
vale, get 0, perdón 00:13:13
este sería el primero 00:13:19
de los discos 00:13:22
vale, entonces uno aquí se podría 00:13:23
plantear, vale, voy a 00:13:26
recorrer los demás 00:13:28
voy a recorrer los demás, en cuanto 00:13:29
encuentre uno cuya duración es 00:13:32
mayor 00:13:34
que la que tiene el máximo hasta ese 00:13:35
momento, tengo nuevo disco 00:13:38
de duración máxima 00:13:40
¿Vale? 00:13:42
Esa sería la primera 00:13:44
Forma de plantear esto 00:13:45
Lo que hemos hecho siempre 00:13:47
Bueno, pues recorremos los discos 00:13:49
Pero del primero ya paso 00:13:50
El primero es este 00:13:52
Y me pongo a recorrer los demás 00:13:55
Vale, empiezo entonces desde el 1 00:13:57
¿Perdón? 00:13:59
¿Pero por qué? 00:14:09
Y en este caso 00:14:12
En este caso no sería por eso 00:14:19
Porque espera, vamos a hacerlo 00:14:22
Porque es que va a salir ahora esa necesidad 00:14:23
Nosotros estamos haciendo por ahora 00:14:24
Como haríamos el planteamiento normal 00:14:28
Luego cuando vamos refinando 00:14:30
Vale, entonces 00:14:31
Aquí, ahora 00:14:33
Seguimos iterando por los discos 00:14:35
Y ahora yo hago, vale 00:14:37
Si el disco 00:14:38
es que cada caso es distinto 00:14:40
aquí el problema no es que se anule 00:14:45
el problema es otro 00:14:46
si el disco de posición 00:14:47
y discoteca 00:14:51
.getdiscos 00:14:53
.geti 00:14:54
aquí habría que decir 00:14:57
si este disco 00:14:59
la suma 00:14:59
de duración de sus pistas 00:15:03
es mayor 00:15:05
que la suma de la duración 00:15:06
de las pistas 00:15:09
de este 00:15:10
entonces tengo un nuevo máximo 00:15:11
¿vale? 00:15:14
claro, pero aquí me viene el problema 00:15:16
esto de aquí 00:15:18
puede ser un CD 00:15:22
o puede ser un vinilo 00:15:25
entonces, aquí 00:15:27
solo tengo que tener en cuenta 00:15:29
solo los que sean CD 00:15:31
los que sean vinilo, ¿no? 00:15:33
entonces, esto será 00:15:36
si este disco de aquí 00:15:37
es CD 00:15:39
solo en ese caso 00:15:41
si es CD, ahora ya miramos 00:15:42
la duración de sus pistas 00:15:45
¿verdad? entonces aquí el primer problema 00:15:46
que nos encontramos es este 00:15:50
de discos.size, perdón 00:15:52
aquí se me ha olvidado el size, vale 00:15:54
entonces 00:15:56
este puede ser 00:15:56
vinilo o puede ser CD 00:16:00
solo me interesa tener en cuenta los 00:16:01
CD, entonces 00:16:04
si este es 00:16:07
CD, si este es 00:16:09
CD, solo en ese 00:16:11
caso, lo primero que tenemos 00:16:13
que hacer es calcular 00:16:15
la suma de la duración de sus pistas 00:16:17
calcular la suma 00:16:19
para ver si la suma de la duración de sus pistas 00:16:21
es mayor que la suma de la duración 00:16:23
de las pistas de este 00:16:25
¿vale? entonces 00:16:26
bueno, pues si este D 00:16:29
vamos a hacer la suma de la duración 00:16:31
de sus pistas, es lo primero que tenemos que hacer 00:16:33
vale, lo podríamos hacer con un método 00:16:35
aparte, pero para no sacar tantos métodos 00:16:37
vamos a hacer la suma 00:16:40
de la duración de sus pistas 00:16:41
suma igual a cero 00:16:43
Recorremos todas las pistas de este 00:16:45
Vale 00:16:48
Pues entonces 00:16:49
Esto como es un CD 00:16:51
Este como es un CD 00:16:54
Como es un CD 00:16:55
El CD tiene un set de pistas 00:16:57
Un set de pistas dentro 00:17:00
¿Verdad? 00:17:02
Pues vamos a recorrer las pistas 00:17:04
Y van para ir sumando en la suma acumulativa 00:17:05
Para ir sumando en la suma acumulativa 00:17:08
La duración de cada pista 00:17:10
La duración de cada pista 00:17:12
Esta 00:17:15
Entonces, aquí uno haría 00:17:15
Vale, pues venga, voy a recorrer 00:17:17
Todas las pistas de 00:17:19
Este CD de aquí 00:17:22
Este 00:17:25
Trollube.get 00:17:26
Pistas 00:17:33
Esto es lo que uno en principio 00:17:34
Querría hacer, ¿verdad? 00:17:38
Todas las pistas 00:17:39
Ahora ya veremos ese rojo 00:17:40
Y ahora hacer 00:17:42
Suma más igual 00:17:42
pista.getDuración 00:17:45
¿Vale? Es decir, esto de aquí es una suma acumulativa 00:17:49
que va recorriendo 00:17:55
todas las pistas del conjunto de pistas de este 00:18:00
CD, ¿vale? Este es el CD, estas son sus pistas 00:18:04
luego este forEach va recorriendo todas y cada una de las pistas 00:18:10
del conjunto de pistas de este CD y va sumando 00:18:14
a la suma acumulativa la duración de cada una de ellas 00:18:18
¿vale? luego esto de aquí 00:18:21
es solo para obtener 00:18:23
lo que suman las pistas de este CD 00:18:25
y ver ya si supera 00:18:27
al máximo 00:18:29
pero efectivamente aquí se nos ha puesto 00:18:29
algo en rojillo 00:18:33
sin mirar esto 00:18:34
sin mirar esto 00:18:35
¿qué mensaje nos estará diciendo 00:18:38
ese rojo de ahí? 00:18:41
efectivamente 00:18:52
nos está diciendo, ojo 00:18:53
discoteca get discos get i 00:18:54
está declarado 00:18:56
es el problema de la herencia 00:18:58
de toda la vida de interfaces 00:19:00
está declarado como disco 00:19:02
porque esto es un elemento 00:19:04
de la colección getDiscos 00:19:07
y la colección getDiscos 00:19:08
es una colección de disco 00:19:10
esta 00:19:12
con lo cual me dice, perdona 00:19:13
yo no tengo ninguna seguridad 00:19:16
o sea, no es que no tenga ninguna seguridad 00:19:18
tú me has declarado eso 00:19:20
como tipo disco 00:19:22
y como me lo has declarado como tipo disco 00:19:23
no puedes llamar a ningún método 00:19:25
que no esté en disco 00:19:28
¿en disco hay algún getPistas? 00:19:29
no, en disco hay reproducir 00:19:31
luego lo único que podemos llamar 00:19:33
aquí es a reproducir, no podemos llamar 00:19:36
a nada más, dices ya, pero hombre 00:19:38
yo quiero llamar a getPistas 00:19:40
porque aunque te lo declare como disco 00:19:42
sé que es un CD 00:19:44
porque lo acabo de comprobar 00:19:45
lo acabo de comprobar, estoy dentro de este if 00:19:47
¿vale? entonces 00:19:49
¿cómo arreglábamos esto? 00:19:51
¿qué hacíamos? 00:19:54
con un casting, ¿vale?, con un casting, ¿vale?, pues entonces, yo sin ningún miedo, hago un casting a CD, ¿de quién?, de ese objeto, de este, sin ningún miedo, hago un casting a CD de este, 00:19:55
porque este, es de tipo CD, porque lo he comprobado antes con el instant off, entonces, como es de tipo CD, me hago el casting a CD, tan feliz, 00:20:14
Y ahora ya, al haber hecho al casting al CD tan feliz, porque sé que no voy a cagarla, porque se ha instanciado como CD, ahora ya dice, ah, vale, me acabas de convertir a CD, ahora ya sí que te dejo llamar al método de CD, de business, ¿vale? 00:20:25
¿Vale? Bueno, pues entonces 00:20:41
Ya tenemos la suma 00:20:47
De todos los 00:20:49
De todas las pistas 00:20:52
De este, y ahora ya habría que ver 00:20:55
Si supera 00:20:57
A la suma de pistas 00:20:58
Del que es máximo hasta ese momento 00:21:01
¿Vale? 00:21:02
De CD máximo 00:21:05
¿Vale? 00:21:06
Y aquí es donde nos viene el problema que dices tú 00:21:08
aquí habría que hacer 00:21:11
¿esta suma de pistas es mayor 00:21:15
que la suma de pistas 00:21:18
del que es máximo hasta ese momento? 00:21:20
pues ojo 00:21:26
hemos inicializado este al primero de la lista 00:21:26
pero espérate 00:21:30
es que el primero de la lista no tiene por qué ser un CD 00:21:32
a lo mejor en mi colección de discos tengo 00:21:35
tres vinilos, un CD, otros dos vinilos, un CD 00:21:37
no, no, no, quiero inicializarlo 00:21:40
al primero que sea cd 00:21:43
al primero que sea cd 00:21:44
lo quiero inicializar, ojo 00:21:46
vale 00:21:48
entonces aquí en este caso 00:21:49
vamos a decir, no, espérate 00:21:53
no lo inicialices al primero, ve avanzando 00:21:55
con un while hasta que llegues a uno 00:21:57
que sea cd y cuando sea cero 00:21:59
inicializas a ese 00:22:01
el ejercicio este que estabas mirando tú 00:22:02
era una situación parecida 00:22:04
pero ahí el problema era otro, que teníamos que inicializarlo 00:22:06
al primero que no fuera null 00:22:08
Bueno, pues aquí podemos hacer 00:22:09
Oye 00:22:14
Aquí, BMA 00:22:14
Mientras 00:22:17
Aquí podemos hacer 00:22:18
Podemos hacer esto 00:22:21
Un int i 00:22:38
Iniciamos a 0 00:22:39
Y mientras esto 00:22:42
Get i 00:22:44
Mientras no sea instancia 00:22:51
De cd 00:22:58
Mientras no sea 00:22:58
instancia de cd 00:23:02
avanzas, a ver he puesto 00:23:03
bien, no, el paréntesis este iría 00:23:07
aquí 00:23:10
ahora si 00:23:10
vale 00:23:12
empezamos con i igual a 0 00:23:24
mientras no sea 00:23:28
una instancia de cd 00:23:31
lo vas avanzando 00:23:32
mientras no sea una instancia de cd lo vas avanzando 00:23:34
y bueno 00:23:37
voy a usar posición porque 00:23:39
el i luego si no abajo 00:23:41
ahora la condición es otra, no es 00:23:42
no sea null, no es no ser null 00:23:52
sino, mientras no sea 00:23:54
una instancia de cd 00:23:56
avanza, avanza, avanza 00:23:58
pos se acabará parando 00:23:59
cuando ya dentro de la lista 00:24:01
ha encontrado una instancia de cd, pos se acabará 00:24:04
parando ahí, vale, pues entonces 00:24:06
ahí ya podemos tener 00:24:08
el máximo 00:24:09
vale, entonces este es 00:24:12
el primer disco de la lista 00:24:28
el primero 00:24:31
que es cd 00:24:31
el primero que cumple la condición de ser cd 00:24:34
el primero que cumple la condición de ser cd 00:24:36
y ahora ya 00:24:38
en lugar de 1 00:24:39
empezamos con los consecutivos a él 00:24:41
empezamos con los consecutivos a él 00:24:44
para cada uno de ellos 00:24:46
si no son cd, nada, no compruebo nada 00:24:48
si son cd 00:24:50
hago la suma 00:24:51
compruebo a ver si es mayor que la suma 00:24:53
del máximo hasta ese momento 00:24:56
si es mayor, tengo nuevo cd máximo 00:24:58
y ya está 00:25:00
y ya habríamos terminado 00:25:01
entonces, vale, he mezclado 00:25:03
Muchas cosas 00:25:06
A propósito 00:25:07
Para que no os perdáis 00:25:09
Estas son las cosas que de alguna manera 00:25:11
Tenéis que ir teniendo sueltas 00:25:13
¿Pero qué compararías? 00:25:15
¿El compare tú de qué clase? 00:25:20
Vale, pero no hace falta 00:25:34
O sea, compare tú de double 00:25:35
Ya es directamente menor o mayor 00:25:37
Bueno, pero primero tenemos que hacer 00:25:38
La suma de las pistas 00:25:43
Primero la de uno y la del otro 00:25:44
Luego ya menor y mayor 00:25:45
No hace falta un compare tú 00:25:46
Porque los números ya se comparan con menor que mayor que 00:25:47
Entonces ahora 00:25:50
Vamos a hacer 00:25:54
La suma del que tiene la duración máxima 00:25:55
Hasta ese momento 00:25:59
La suma del que tiene la duración máxima 00:26:00
La podemos dejar aquí calculadita también ya 00:26:02
Para no tener que volverla así 00:26:04
No tener que volver a hacerla así 00:26:05
Entonces aquí podríamos hacer 00:26:07
Insuma máxima 00:26:09
Y con este método 00:26:11
Revisándolo 00:26:13
Ya nos vamos ¿Vale? 00:26:15
Pues volveríamos a hacer esto, getPost sería aquí, getPistas, suma máxima, vale, entonces, en esta primera inicialización, hemos obtenido el primer CD de la lista, el primer CD, y ahora lo que suman, las pistas suyas, lo que suman las pistas suyas, vale. 00:26:17
Ahora ya nos vamos con los demás 00:26:46
Si alguno de ellos 00:26:48
De los que este de 00:26:51
La suma de sus pistas 00:26:53
Que la hemos calculado aquí 00:26:55
La suma de sus pistas es mayor 00:26:56
Que la suma máxima hasta ese momento 00:26:58
Pues entonces 00:27:01
Tengo nuevo 00:27:03
C de máximo 00:27:04
Tengo nuevo C de máximo 00:27:06
Que es este 00:27:08
Este de aquí 00:27:09
Y tengo nueva suma máxima 00:27:12
que es esta 00:27:20
y ya la habríamos terminado 00:27:21
nos faltaría devolver, claro 00:27:25
como valor de retorno, ahora lo revisamos entero 00:27:28
nos faltaría 00:27:30
devolver como valor de retorno 00:27:32
return cd máximo 00:27:34
vale 00:27:36
entonces aquí 00:27:37
por el tema de la herencia, por el tema de eso 00:27:39
esto 00:27:42
se ha ido complicando, claro 00:27:43
pero la idea es 00:27:45
primero uno tiene que pensar que tiene que hacer 00:27:47
Aquí tengo que calcular dentro de una colección de discos 00:27:49
El que más cumple algo 00:27:52
Vale, pues ya está, eso siempre funciona de la misma manera 00:27:53
El primero de todos 00:27:56
Es el máximo inicial 00:27:57
Recorro los demás 00:28:00
Y si superan al máximo, tengo nuevo máximo 00:28:01
Bueno, cuando hemos empezado a refinar eso 00:28:03
Nos hemos encontrado los problemas específicos 00:28:05
De cada caso 00:28:08
Y ya los hemos resuelto así 00:28:09
Primero, ¿qué hemos hecho? 00:28:11
Encontrar la posición 00:28:14
Del primer elemento de la lista 00:28:15
Esta, del primer elemento que es CD 00:28:17
porque son los únicos que vamos a tener en cuenta 00:28:19
vale, pues ya está, ya la hemos encontrado 00:28:21
esta es la posición del primero que es CD 00:28:24
bueno, pues ahora 00:28:26
ese se ha convertido 00:28:29
en el máximo inicial 00:28:33
y la suma de sus pistas es esta 00:28:34
máximo inicial 00:28:37
con la suma de sus pistas, vale 00:28:39
ahora, ya sí que nos hemos 00:28:41
ido a la colección 00:28:43
para empezar a recorrer los que nos faltan 00:28:44
desde pos más uno hasta el final 00:28:47
para cada uno de ellos 00:28:48
si son CD, porque si no los ignoramos 00:28:50
si son CD 00:28:53
sumamos la duración de sus pistas 00:28:55
la sumamos, para lo cual 00:28:57
hemos tenido que hacer el casting, etc. 00:28:59
la sumamos 00:29:00
si la suma de sus pistas es mayor que la que es 00:29:01
máxima hasta ese momento 00:29:04
tengo nueva duración máxima 00:29:05
y nuevo CD máximo y ya está 00:29:08
cuando el for ha terminado tengo ya 00:29:10
el valor final 00:29:12
que devuelvo y se acabó 00:29:14
¿vale? 00:29:16
bueno, pues 00:29:24
con este proyecto 00:29:24
es un ejemplo de mezclar 00:29:26
varias cosas y estos son un poco los conceptos 00:29:28
que tenéis que tener claros, aparte de lo 00:29:30
de programación básico de toda la vida 00:29:32
el uso de las sentencias de control 00:29:35
pues eso de sumar, de contar 00:29:36
de los máximos, de los mínimos, aparte de 00:29:39
todo eso, luego ya 00:29:41
los temas de herencia, interfaces 00:29:42
y el polimorfismo 00:29:45
es decir 00:29:46
sobre escribir métodos 00:29:48
que un mismo método funciona 00:29:50
de diferente manera en función de 00:29:52
El objeto que lo llama 00:29:54
Etcétera 00:29:55
Todo esto de la herencia 00:29:57
Y luego ya el manejo de las colecciones 00:29:59
¿Vale? 00:30:01
Pues ya está 00:30:04
Vamos a parar aquí 00:30:06
Si no tenéis 00:30:08
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
3 de abril de 2024 - 18:35
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
30′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
133.55 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid