Saltar navegación

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

Clase 19-02-24 - 3 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 26 de febrero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Cosita antes de irnos. 00:00:00
Vale. 00:00:02
Pues nada, porcentaje de alumnos, ya que estábamos, incluimos esta funcionalidad y seguimos repasando. 00:00:04
Pues nada, porcentaje de alumnos, he contado los aprobados. 00:00:10
Y para ver el porcentaje de aprobados, pues ahora ya tenemos que hacer la regla de 3 hasta 100, ¿no? 00:00:14
El porcentaje de aprobados sería 00:00:21
Sería 00:00:24
El total 00:00:29
Multiplicado por 00:00:30
O sea, el total de aprobados 00:00:33
Multiplicado por el total dividido entre 100 00:00:35
¿No? 00:00:37
No sé si estoy haciendo bien la regla de 3 00:00:39
El total sería alumnos.led 00:00:40
No, no, perdón 00:00:43
Este entre 00:00:44
El total multiplicado por 100 00:00:46
Ese sería el porcentaje 00:00:48
Alumnos.led 00:00:50
hay repositorio alumnos, perdón 00:00:52
punto alumnos y todo esto 00:00:54
multiplicado por 100 00:01:02
ala 00:01:03
punto alumnos, punto lens 00:01:05
ala, ya está 00:01:10
vale, este sería 00:01:12
el porcentaje de aprobados, ¿no? 00:01:14
que es 00:01:17
mis aprobados entre los totales 00:01:18
multiplicado por 100 00:01:20
mis aprobados que es 00:01:21
entre los totales 00:01:25
lo voy a bajar aquí abajo 00:01:27
lo del paréntesis 00:01:28
para que se vea. 00:01:30
Mis aprobados 00:01:34
entre el total de alumnos 00:01:35
que tengo, el total de alumnos 00:01:37
multiplicado por 100. 00:01:39
Ese es el porcentaje aprobado. 00:01:41
Pues nada, funcionalidad por hacer alguna cosita más. 00:01:43
Que no se quede la aplicación ahí tan 00:01:45
cortita. 00:01:47
Vale, ya habríamos terminado el caso 2. 00:01:50
Le hacemos el break. 00:01:52
Caso 3. 00:01:54
Mostrar el listado. 00:01:56
Este es un for que recorra. 00:01:57
nada 00:01:58
el caso 3 00:02:00
pues ahora ya esto sí que podemos hacer un for 00:02:03
ahí cómodo 00:02:05
para cada alumno 00:02:06
en mi array de alumnos 00:02:09
repositorio.alumnos 00:02:11
mostramos 00:02:14
vamos a mostrar el nombre y la nota 00:02:20
en el listado 00:02:24
nombre 00:02:25
apunto get nota 00:02:29
vale, el listado que tenga solamente eso 00:02:35
Nombre y nota, por ejemplo 00:02:42
¿Vale? Nombre y nota 00:02:49
Y ahora ya tendríamos el caso 4 00:02:50
Que es el 00:02:54
Que ha motivado toda esta pequeña aplicación 00:02:55
Vamos a dejarlo en su vacío 00:03:00
Y vamos a probar la aplicación antes de nada 00:03:04
Para ver si hemos hecho algo mal 00:03:06
Vamos a probarla antes de nada 00:03:08
Pues nada, ya nos venden la aplicación 00:03:11
Salvo por una funcionalidad que está por hacer 00:03:15
Ordenar por nota, ya nos la han vendido 00:03:17
Vamos a probarla a ver si nos la han hecho bien 00:03:18
Venga, introduce un alumno 00:03:21
Pues aún no va a ser un 2, 3, 4 00:03:23
Vale, se va a llamar Pepito 00:03:25
Y va a tener un 7 00:03:28
Pues nos lo han hecho fatal 00:03:29
Porque nos ha sido una excepción 00:03:31
¿No? 00:03:32
Pues yo desde luego algo he hecho mal 00:03:35
Se me ha salido del array 00:03:37
¿Dónde se me ha salido del array? 00:03:39
Me voy aquí 00:03:42
aux.led 00:03:43
menos 1 igual a 00:03:45
Aquí, es que yo esto no lo he puesto así 00:03:47
Esto se me había olvidado a mí 00:03:49
¿Vale? 00:03:52
Lo que hemos hecho así todo seguido se me había olvidado eso 00:03:53
Vale, que a vosotros seguramente no 00:03:55
Y por eso nos ha dado problemas, pero a mí se 00:03:59
Venga, pues volvemos 00:04:01
A ejecutar la aplicación, a ver si ahora 00:04:03
Esto que me han vendido funciona 00:04:05
Ah, le vamos a entrar a un alumno 00:04:06
Pues venga 00:04:09
Este es su NIF 00:04:10
Este es su nombre 00:04:12
Y esta es su nota 00:04:14
Vamos a insertar otro, a ver 00:04:16
Ah, no, es que le he dado a la opción 2 00:04:19
2 me dice porcentaje de aprobados 100% 00:04:26
Parece que está funcionando 00:04:28
Vamos a insertar otro 00:04:29
Que este esté suspenso, a ver si ahora me sale porcentaje 50 00:04:31
2, 2, 2 00:04:34
Vale 00:04:36
Y esta tiene un 3 00:04:37
A ver qué porcentaje de aprobados me sale 00:04:40
Porcentaje de aprobados 0 00:04:43
Uff 00:04:46
Me tendría que salir 50, ¿verdad? 00:04:47
Vamos a mostrar el listado 00:04:54
Pepito 7, Anita 3 00:04:55
entonces el porcentaje de aprobados 00:05:00
no me lo está haciendo bien, porque tiene 00:05:02
Pepito 7, Anita 3 00:05:03
y cuando yo doy porcentaje de aprobado 00:05:05
me dice 0, entonces ese cálculo 00:05:07
esa cuenta, algo ahí he hecho mal 00:05:09
a lo mejor tiene que ver con los castings de Inde 00:05:11
de Abel, por ahí pueden ir 00:05:13
las cosas, cuidadín 00:05:15
cuando hacemos divisiones 00:05:17
cuidadín 00:05:19
porque la división uno siempre 00:05:20
interpreta que va a tener 00:05:23
su parte decimal, pero no 00:05:25
Si involucra números enteros 00:05:27
La parte decimal ahí no cuenta 00:05:28
¿Vale? Cuidadín 00:05:30
Entonces ahora 00:05:31
El que ha hecho el equipo de pruebas 00:05:33
Le dice, oye, no me has pasado 00:05:36
El test 00:05:39
No ha pasado con éxito 00:05:39
El test del porcentaje de aprobados 00:05:42
No ha pasado con éxito 00:05:44
A ver qué ha pasado 00:05:45
Nos vamos a la funcionalidad de porcentaje de aprobados 00:05:47
Main 00:05:51
Porcentaje de aprobados 00:05:52
¿Vale? 00:05:54
me va contando 00:05:57
¿qué pasa? 00:05:58
¿vale? lo he hecho a propósito 00:06:04
para que no salga esto 00:06:05
adiós 00:06:06
¿qué ha pasado? 00:06:08
¿qué peligro tienen 00:06:10
mezclar divisiones y números enteros? 00:06:11
¿qué peligro tienen? 00:06:14
cuidado con eso 00:06:15
que lo hacemos así muy 00:06:16
cuando yo lo he escrito 00:06:19
parecía que tenía todo el sentido del mundo 00:06:21
¿verdad? 00:06:23
pero ¿qué está pasando en este ejemplo? 00:06:24
En esta ejecución en concreta que yo he hecho, 00:06:28
repositorio de alunas putuleces dos 00:06:31
y contes uno. 00:06:32
Pero están guardados como int. 00:06:36
Con lo cual, al estar guardados como int, 00:06:39
la división es la división entera. 00:06:41
Acordaos del principio de curso. 00:06:44
Este operador división 00:06:45
tiene dos formas de funcionar. 00:06:47
La división entera y la división decimal. 00:06:50
¿Cuándo funciona como división entera? 00:06:53
cuando los operadores con los que trabaja son int 00:06:55
en ese caso 00:06:58
trunca la parte decimal completamente 00:07:00
cuando trabaja 00:07:02
como división decimal 00:07:04
cuando los operadores con los que trabaja son double o float 00:07:05
entonces no trunca la parte decimal 00:07:08
en este caso count es int 00:07:10
lo tengo ahí arriba 00:07:12
y repositorio.alumno.length es la longitud 00:07:13
que me la devuelve int 00:07:16
bueno en long pero es entero igual 00:07:17
con lo cual la división es 00:07:19
sin parte decimal 00:07:22
luego 1 entre 2 00:07:23
no es 0,5 00:07:27
como uno puede creer 00:07:29
que es 0,5 y a multiplicar por 100 00:07:31
le sale 50 00:07:33
no es 0,5 00:07:34
1 entre 2, ¿cuánto es? 00:07:36
1 entre 2, división entera, ¿cuánto es? 00:07:40
recordad que la división entera es el cociente 00:07:42
pues 1 entre 2 es 0 00:07:45
por eso me dice, oye, 0 por 100 00:07:47
entonces cuidado 00:07:50
porque esta tontería a veces 00:07:53
genera muchos problemas en una aplicación 00:07:54
y en este caso 00:07:57
es una cosa muy sencilla 00:07:59
porque nuestra aplicación es cortita 00:08:00
y podemos acotar el problema 00:08:03
pero esto puede estar dentro de un método 00:08:04
que a su vez llama a otro, que a su vez llama a otro 00:08:07
y no tienes ni idea de por qué te estás haciendo mal 00:08:08
y simplemente es 00:08:11
porque estás haciendo una división creyendo que 00:08:13
conservas la parte decimal 00:08:15
y no la conservas porque le estás pasando operadores enteros 00:08:16
¿vale? 00:08:19
entonces 00:08:20
¿qué arreglo podríamos hacer aquí? 00:08:23
hay varias posibilidades 00:08:28
cualquiera que se os ocurra 00:08:29
claro, un casting, podríamos hacer un casting 00:08:31
entonces si hacemos un casting 00:08:35
entero 00:08:37
entre, ya con que uno de los dos 00:08:38
sea dable 00:08:41
recordad que entonces 00:08:42
la máquina virtual de Java al otro le hace la promoción 00:08:44
automática 00:08:47
porque llevar de int a dable 00:08:48
no es problema, es poner .000 00:08:51
no cambia información 00:08:53
Sin embargo, llevar de double a int 00:08:54
Claro que es problema 00:08:56
Porque llevar de double a int 00:08:57
Quitas la parte decimal 00:08:59
Luego quitas información 00:09:00
Entonces, si la división entera 00:09:01
Se encuentra un double y un int 00:09:04
Él hace automáticamente la promoción del int 00:09:06
Ya tiene dos double 00:09:09
Y la división se queda como double 00:09:10
Es decir, parte decimal 00:09:12
Y ya está 00:09:14
Podríamos hacer un casting 00:09:15
O podríamos hacer otra cosa 00:09:16
Que es cambiar el orden 00:09:18
Multiplicar primero por 100 00:09:20
Y luego hacer la división 00:09:21
vale, si yo multiplico primero por 100 00:09:22
el numerito, que este 00:09:26
siempre va a ser menor que este 00:09:28
porque esta es una cuenta que se hace 00:09:29
sobre el total, entonces la cuenta siempre va a ser 00:09:32
menor, entonces esto siempre va a ser 0 00:09:33
ese es el problema, que eso siempre va a ser 0 00:09:35
porque cont 00:09:38
siempre va a ser menor o igual que el 00:09:38
total 00:09:42
bueno, pues yo cambio el orden, primero multiplico 00:09:42
cont por 100 y luego ya hago 00:09:46
la división 00:09:47
vale, entonces 00:09:48
ahora ya, si yo cambio 00:09:50
esto, no tengo que hacer casting ni nada 00:09:53
que los casting, a veces uno los ve 00:09:55
cuando uno abre una aplicación y ve, muchas veces hay que hacer 00:09:57
casting porque no hay remedio, no hay más remedio 00:09:59
pero quedan tan feos 00:10:01
porque tienen tanto peligro, que si uno puede 00:10:03
arreglar las cosas de otra manera, pues mejor 00:10:05
.alumnos.length 00:10:06
ala 00:10:13
ahora ya, cont por 100 00:10:15
¿vale? será mayor 00:10:18
que el total 00:10:20
con lo cual esto 00:10:21
Esta división entera ya no va a ser cero 00:10:25
Eso sí, el porcentaje me va a dar siempre sin decimales 00:10:28
El porcentaje se va a redondear 00:10:31
Si yo quiero que me dé el porcentaje con decimales 00:10:32
Tendría que hacerlo del casting 00:10:35
¿Vale? Tendría que hacerlo del casting 00:10:36
Lo que más os guste 00:10:38
Yo ahora he puesto esta porque esto quizás es más difícil 00:10:39
De ver que lo otro 00:10:42
Entonces prefiero poner la opción que es más difícil de 00:10:44
Ver para que la 00:10:46
Penséis 00:10:48
Entonces ahora ya decimos, oye ya he visto que ha pasado 00:10:49
¿Por qué no he pasado el testing? 00:10:52
Venga, ya ha hecho la versión, vuelve, se lo pasas otra vez al equipo de testing y te dice, venga, vamos a volver a hacer la prueba. 00:10:55
Insertar alumno, ala, esta que tiene un 4, vamos a insertar otro más, esta que tiene un 10, vamos a ver porcentaje de aprobados, 50. 00:11:05
vale, a ver, esto es una única prueba 00:11:20
patatera, obviamente habría que hacer 00:11:23
muchas pruebas 00:11:25
porque puede haber casos 00:11:26
para los cuales no funcione, que no hayamos tenido en cuenta 00:11:28
pero bueno, es un programa tan pequeñito 00:11:30
que es que no tiene muchas más 00:11:32
opciones de fallo, pero en condiciones normales 00:11:34
habría que hacer una fase de pruebas 00:11:37
mucho más larga 00:11:39
pero bueno, tiene pinta de que 00:11:39
lo que hemos hecho ahora ya sí que está bien 00:11:43
vamos a mostrar el listado, ya lo hemos probado 00:11:44
antes, Ana tiene un 4 y va a un 10 00:11:47
vale, bueno pero la aplicación está a medias 00:11:49
nos falta mostrar el listado 00:11:51
ordenado por nota 00:11:53
que esta es la interesante 00:11:54
bueno, pues aquí 00:11:56
tenemos que empezar a ordenar el array 00:12:01
empezar a subir 00:12:04
para arriba, para abajo en función de la nota 00:12:06
un pifostio 00:12:08
los algoritmos de ordenación 00:12:09
no son tan sencillos 00:12:12
no son tan sencillos 00:12:14
de hecho 00:12:15
está todo estudiado 00:12:16
y hay varios algoritmos de ordenación ya propuestos y desarrollados 00:12:19
para que tengan la menor complejidad posible. 00:12:24
Porque ordenar una colección de datos no es una destreza de programación fácil. 00:12:28
No es fácil ordenar. 00:12:36
No es fácil. 00:12:38
Entonces se han propuesto varios algoritmos de ordenación. 00:12:39
Está el de la burbuja, que es el más sencillo de programar 00:12:44
pero que tiene demasiadas 00:12:48
iteraciones, está el 00:12:50
quick sort, que es más 00:12:52
complicado de programar, de entender 00:12:54
porque es recursivo, pero tiene menos 00:12:56
iteraciones, ¿vale? hay algoritmos que están 00:12:58
propuestos, si uno busca en wikipedia 00:13:00
donde sea algoritmo de donación, los tienes ahí 00:13:02
todos puestos, con 00:13:04
la complejidad que tiene cada uno 00:13:06
medida la complejidad en número de iteraciones 00:13:08
que da el bucle, cuanto menos mejor 00:13:10
¿vale? 00:13:12
lo puedes poner, ¿cómo es este algoritmo en java? 00:13:14
no sé si nos dará tiempo 00:13:17
normalmente veíamos esos algoritmos 00:13:18
los programados para entenderlos 00:13:20
porque es una tarea de lógica 00:13:22
y de matemáticas muy interesante 00:13:24
es una cuestión de lógica y de matemáticas 00:13:26
no tiene que dar tiempo este curso 00:13:28
porque tenemos que 00:13:30
acelerar un poco 00:13:31
pero en nuestro problema, ¿qué haríamos? 00:13:34
pues uno podría decir 00:13:37
oye, me voy a buscar uno de esos algoritmos 00:13:38
de ordenación y lo voy a aplicar 00:13:40
lo voy a programar ese algoritmo 00:13:42
para mi array, es una cosa 00:13:44
que podría hacer, y la haría y ya está 00:13:46
se busca un algoritmo 00:13:48
y lo programa 00:13:50
aplicado a este array 00:13:51
y ya los tiene ordenados 00:13:53
pero afortunadamente 00:13:55
la máquina virtual de Java, como ya hemos dicho 00:13:58
nos incorpora una librería 00:14:00
con un montón de cosas ya hechas 00:14:01
cuando tenemos que hacer 00:14:03
el seno de un ángulo 00:14:06
no hacemos nosotros el algoritmo para el seno 00:14:07
del ángulo, tenemos la librería math 00:14:10
que tiene el método sin, que nos hace el seno 00:14:12
y así un montón de cosas 00:14:14
si queremos hacer la potencia de uno 00:14:16
elevado a otro 00:14:18
no nos hacemos cada dos por tres 00:14:19
el bucle que va multiplicando por sí mismo 00:14:22
llamamos al método POU 00:14:24
de la librería MAD que ya lo hace 00:14:26
entonces las clases de la máquina virtual 00:14:28
tienen un montón 00:14:30
de utilidades para hacer cosas 00:14:32
entonces si uno indaga y cotillea 00:14:34
por ahí, pues ve que 00:14:36
porque es lo que uno hace, buscar 00:14:38
buscar que recursos tiene para hacer 00:14:40
cosas, pues ve que 00:14:42
tiene una clase Arrays que está por ahí en algún sitio 00:14:44
y que 00:14:46
esta clase Arrays tiene ahí la bomba 00:14:48
¿vale? esta clase 00:14:50
Arrays 00:14:52
que está aquí 00:14:53
en el paquete 00:14:56
Java útil 00:14:58
pues en el paquete Java útil está esta clase Arrays 00:14:59
que uno lee aquí lo que tiene 00:15:02
y tiene un montón de 00:15:04
métodos estáticos estupendos para 00:15:06
hacer cosas en general con Arrays 00:15:08
para hacer cosas con Arrays 00:15:10
tiene ahí de todo 00:15:12
vale, pues cuando uno descubre 00:15:14
que existe esa clase, dice, hombre 00:15:16
pues justo 00:15:18
lo que yo quiero hacer es ordenar un array 00:15:20
hacer una cosa con un array 00:15:22
esta clase array que tiene un montón de métodos 00:15:23
estáticos para hacer cosas con array 00:15:26
tendrá precisamente 00:15:27
un método que me ordene 00:15:30
un array 00:15:32
pues uno lo busca y dice, anda pues sí 00:15:33
ahí lo tiene, tiene un método 00:15:36
que se llama sort 00:15:40
entonces 00:15:43
con ese nombre pues obviamente lo que se hace 00:15:45
es ordenar, vosotros pues 00:15:48
que sois bilingües lo tenéis más fácil 00:15:52
¿vale? 00:15:54
y este método sort 00:15:56
le pasas un array y te lo ordena 00:15:57
eso te dice la 00:16:00
ayuda, el java2 00:16:01
que va con arrays, te dice tú pásame un array 00:16:04
que yo pa pa pa te lo coloco y te lo ordeno 00:16:06
vamos a mostrarlo 00:16:08
ahora después porque nos lo ha ordenado 00:16:13
pero vamos a mostrarlo 00:16:14
para cada alumno 00:16:16
repositorio.alumnos 00:16:22
un segundín, vamos a mostrar 00:16:32
otra vez el nombre y la nota 00:16:36
y tú le puedes pasar efectivamente 00:16:38
un array de cualquier tipo 00:16:48
de datos, yo le he pasado uno de alumnos 00:16:50
pero le podría pasar un array de enteros 00:16:52
un array de lo que fuera 00:16:54
yo le he pasado un array de alumnos 00:16:55
entonces, dice Jolines 00:16:59
pues que fácil lo tengo 00:17:04
tengo mi método sort estático 00:17:05
de la clase Arrays que ya me hace eso 00:17:08
no tengo que programar yo un algoritmo de ordenación 00:17:09
tipo la burbuja, tipo el que sea 00:17:12
y ya está 00:17:13
me lo ordena y lo voy a mostrar a ver si está ordenado 00:17:16
entonces, ¿no surge 00:17:18
así de buenas a primeras alguna 00:17:21
no hay nada que nos descuadre en la cabeza ahora mismo? 00:17:23
sí, pero no 00:17:33
ya, pero claro, esa es la pregunta de la que yo iba 00:17:33
short dice 00:17:36
yo te lo ordeno, pero ¿a algún momento le hemos dicho 00:17:38
con qué criterio? ¿se puede ordenar por orden alfabético? 00:17:40
¿se puede ordenar por nota? 00:17:43
¿se puede ordenar porque me caiga mejor o peor? 00:17:44
yo no le he dicho 00:17:47
al programa, no le he dicho a short 00:17:48
el criterio de ordenación 00:17:49
porque los números 00:17:51
tienen un criterio ya inherente a ellos 00:17:53
que es el orden 00:17:56
matemático, que conocemos 00:17:58
¿vale? del álgebra 00:17:59
que nosotros conocemos 00:18:02
¿vale? no es el único orden posible 00:18:05
pero es el orden al que nosotros estamos 00:18:07
acostumbrados, entonces los números lo tienen 00:18:09
un orden inherente, es que no tendríamos que 00:18:12
darle al sort un criterio 00:18:14
si le paso una raíz de números 00:18:16
ya asume que los va a ordenar 00:18:17
según el criterio 00:18:20
de mayor y menor que nosotros conocemos 00:18:22
pero es que los alumnos 00:18:24
deben un criterio de orden inherente 00:18:26
suyo, se puede ordenar de muchas maneras 00:18:28
por altura 00:18:30
por nota, por orden alfabético 00:18:31
por número de deniz 00:18:35
no hay 00:18:36
un criterio 00:18:38
universal para ordenar 00:18:40
alumnos, entonces efectivamente 00:18:42
aquí algo me escama, me dice 00:18:44
lo ha tragado 00:18:46
lo ha tragado pero yo no le he 00:18:48
dicho como los va a ordenar 00:18:50
uno podría plantearse ejecutar esto 00:18:52
pues si lo ha tragado, algo hará 00:18:54
uno podría plantearse ejecutarlo 00:18:55
vamos a ejecutarlo 00:18:58
vamos a insertar dos para que 00:19:01
tenga 00:19:07
número de alumnos 00:19:09
que ordenar, vale, venga 00:19:13
vamos a, el listado está, aquí están 00:19:20
los dos, y ahora vamos 00:19:22
a mostrar el listado ordenado por 00:19:26
nota, claro, él lo ha tragado 00:19:28
pero luego a la hora de 00:19:32
ejecutar me dice 00:19:34
alumno 00:19:36
no lo puedo 00:19:37
cambiar a comparable 00:19:40
Es una forma de decirme, los alumnos no son comparables entre sí. 00:19:42
Me está diciendo, para ordenar, tengo yo que comparar cuál es mayor y menor, 00:19:47
sea con el criterio que sea. 00:19:52
Te está diciendo, perdona, estos alumnos, cuando yo me he puesto a compararlos, 00:19:53
no puedo compararlos, no puedo compararlos. 00:19:57
¿Vale? 00:20:01
Entonces, los que no hay errores de compilación, obviamente no significa que esté todo bien. 00:20:02
Aquí está, fatal. 00:20:06
¿Vale? Pues, ¿qué es lo que pasa aquí? 00:20:08
que mis alumnos 00:20:10
que tienen 00:20:13
su NIF, su nombre y su nota 00:20:14
no les basta para ser ordenados 00:20:16
con que tengan su NIF, su nombre y su nota 00:20:18
lo que tienen también es que 00:20:20
implementar 00:20:22
la funcionalidad de poder 00:20:24
ser comparados 00:20:26
¿y esto en qué se traduce en Java? 00:20:27
pues es el mismo patrón de interfaz que hemos visto antes 00:20:32
Java nos da una interfaz 00:20:34
que se llama comparable 00:20:36
literalmente, comparable 00:20:38
esa interfaz comparable 00:20:40
significa poder ser comparados entre sí. 00:20:42
Igual que la interfaz empleado-despedible 00:20:45
significaba poder ser despedidos. 00:20:48
Pues la interfaz comparable 00:20:51
significa poder ser comparados. 00:20:52
Entonces, si yo quiero que mis alumnos 00:20:55
se puedan comparar entre sí para ordenarlos, 00:20:56
tienen que incorporar ese comportamiento. 00:21:00
Tienen que incorporarlo. 00:21:04
Si no, no pueden ser comparados. 00:21:06
E incorporar un comportamiento 00:21:07
es implementar la interfaz 00:21:09
que lo recoge, implementarla 00:21:11
igual que el empleado 00:21:13
temporal y empleado externo 00:21:15
incorporar el poder ser despedidos 00:21:17
significaba que implementaran 00:21:19
empleado despedible 00:21:22
pues para que los alumnos puedan 00:21:23
ser comparados, tienen que 00:21:25
implementar la interfaz 00:21:27
comparable, que es la que les da 00:21:29
la que les da el carácter 00:21:31
de comparables, de poder 00:21:33
ser comparados entre sí 00:21:36
esa interfaz ya existe, es una de las miles 00:21:37
que hay por aquí, lo único que tiene que hacer 00:21:39
mi alumno ahora, mi alumno es 00:21:41
implementarla, ala 00:21:43
ya implementa comparable 00:21:52
¿vale? pero claro 00:21:54
¿qué pasa cuando una clase 00:22:00
implementa una interfaz? 00:22:02
como el ejemplo de antes 00:22:06
edificio, empleado temporal 00:22:07
empleado externo 00:22:10
implementaba empleado despedible 00:22:10
pero cuando lo implementaba decía, oh que tú eres despedible 00:22:13
pues perdona, dime cómo te hacemos 00:22:16
el finiquito, si no me lo dices no puedes 00:22:18
y eso se traducía 00:22:20
en implementar 00:22:22
el método, generar finiquito 00:22:24
pues esto igual, dices, oye que tú 00:22:26
quieres implementar comparable 00:22:28
vale, pero dime cómo te comparo 00:22:29
si no me lo dices, cómo te comparo 00:22:31
pues es lo que me está diciendo, me está diciendo, oye si implementas 00:22:33
comparable, tienes que 00:22:36
dar código, tienes que implementar 00:22:38
tienes que dar código a los 00:22:40
métodos de comparable, tienes que darlo 00:22:42
y cuáles son los métodos de comparable 00:22:44
Pues el compare tú, precisamente, que te dice cómo comparar un alumno con otro. 00:22:46
Entonces, si implementamos ese método, es este. 00:22:52
Ahora ya se cae al compilador, es este. 00:22:57
Vale, pues este método, este método es el método que van a usar las otras clases, 00:23:03
como la clase a raíz, que quieran comparar un alumno con otro. 00:23:11
Pero claro, lo van a usar siguiendo un criterio común, estándar. 00:23:15
Entonces, lo que significa el método es, este método lo va a llamar un objeto alumno y se le va a pasar como parámetro a otro objeto alumno. 00:23:19
Como veis, lo declara como object porque todavía no sabemos parametrizar, ya más adelante, olvidaos de eso, pero es que dentro de object cabe un objeto alumno y cabe cualquiera, obviamente, cabe cualquiera, porque es object. 00:23:28
Pues a este método lo va a llamar un alumno y le va a pasar otro alumno. 00:23:39
bueno, pues el convenio 00:23:43
que seguimos es 00:23:46
que esto va a devolver un entero 00:23:47
si el numerito que devuelves es negativo 00:23:49
entonces el que llama al método 00:23:51
se sobreentiende que va antes 00:23:54
si devuelve cero 00:23:56
se sobreentiende 00:23:58
que son iguales 00:24:00
que están en la misma posición 00:24:02
y si devuelve un número que sea 00:24:03
positivo, se sobreentiende 00:24:06
que el que llama al método va después del otro 00:24:08
ese es el criterio 00:24:10
Y ese es el criterio que usa Arrays 00:24:12
y que usa cualquier clase que necesite comparar cosas. 00:24:15
La clase Arrays con el método sort 00:24:20
llamará al compareTo para comparar. 00:24:22
Cuando salga negativo interpretará 00:24:26
que el que llama al método va antes. 00:24:28
Cuando salga cero que son iguales. 00:24:29
Cuando salga positivo interpretará 00:24:31
que el que llama al método va después. 00:24:33
Bueno, pues entonces tenemos que programar este método 00:24:36
siguiendo ese criterio. 00:24:38
entonces si vamos a programar por nota 00:24:40
vamos a hacerlo muy extendido 00:24:43
que luego lo podremos simplificar 00:24:45
pues si el objeto que llama 00:24:47
el método punto nota 00:24:49
resulta que es menor 00:24:50
que la nota de este 00:24:53
pero claro 00:24:55
yo no puedo llamar 00:25:01
a la nota de este objeto, ¿verdad? 00:25:03
porque es obvio 00:25:05
pero no pasa nada, ¿qué hago? 00:25:06
¿qué hago para poder llamar a la nota de este objeto 00:25:12
en casting? 00:25:15
yo sé que el que le voy a pasar es un alumno 00:25:17
entonces no pasa nada, me hago un casting 00:25:19
hala, ya está 00:25:21
pues si la nota del que llama 00:25:29
el método es mayor que la nota de este 00:25:31
si ordeno 00:25:33
en orden ascendente 00:25:35
pues entonces 00:25:36
voy a devolver un número negativo 00:25:38
por ejemplo el menos uno 00:25:41
con eso indico 00:25:47
que este va antes que el otro 00:25:51
si devuelvo el negativo, el que llama el método 00:25:52
va antes que el otro, devuelvo un negativo 00:25:55
vale 00:25:56
si no 00:25:57
si la nota es mayor 00:25:59
pues entonces el que llama 00:26:02
al método va después 00:26:10
pues entonces 00:26:12
voy a devolver un positivo para indicarlo 00:26:14
y si no es ni mayor ni menor 00:26:16
es que las notas son iguales 00:26:20
pues están en la misma posición en cuanto a su orden 00:26:21
en ese caso devuelvo cero 00:26:24
bueno pues esta sería 00:26:25
una implementación del compare tú 00:26:28
que dice que los alumnos se ordenan 00:26:30
por 00:26:33
nota 00:26:34
ascendente. 00:26:36
Va antes el que menos nota tenga. 00:26:39
¿Vale? Pues entonces, alumno implementado 00:26:43
comparable, para decirle al mundo 00:26:44
que lo quiera usar, 00:26:46
oye, que los alumnos son comparables entre sí. 00:26:48
O sea, al implementar comparable, 00:26:50
la clase alumno le está diciendo al mundo, 00:26:52
oye, que quien necesite ordenarme 00:26:54
va a poder. 00:26:56
Antes, si no implementabas comparable, 00:26:58
tú no le estabas diciendo al mundo 00:27:00
el que quiera ordenarme va a poder. 00:27:01
Ahora le dices, oye, el que quiera ordenarme 00:27:04
puede. El que quiera ordenar a alumnos 00:27:06
va a poder. En este caso concreto 00:27:08
¿quién va a querer ordenarle? 00:27:10
Pues Orto. 00:27:12
Pero podría haber otros métodos, otras cosas que necesitan 00:27:14
ordenarle. Pero en este caso 00:27:16
estamos usando esta. 00:27:18
Pues con esto le decimos al mundo 00:27:20
que los alumnos pueden ser ordenados 00:27:22
entre sí. Pero no basta con informar 00:27:24
a los cuatro vientos 00:27:26
de que los alumnos pueden ser ordenados entre sí. 00:27:27
Hay que implementar el criterio, hay que implementar el criterio, si hemos decidido porque a nuestra aplicación es el que le interesa que sea por nota, pues entonces ponemos esto, lo importante es devolver menos uno o negativo si el que llama al método va antes que el parámetro, devolver cero es de la misma posición y devolver algo que sea positivo si el que llama al método va después, eso es lo importante. 00:27:30
bueno, pues ya está, así lo puedo hacer 00:27:57
hombre, tendría una versión un poquito 00:28:01
más resumida de este método 00:28:02
¿verdad? si yo le hago 00:28:04
esto, return 00:28:06
dis.nota 00:28:10
menos 00:28:13
esto de aquí, ¿verdad? 00:28:15
me falta algún paréntesis o me 00:28:23
sobra o 00:28:25
me sobra 00:28:26
¿vale? porque 00:28:28
si la nota del que llama al método 00:28:31
es más pequeña que la del otro 00:28:33
esta resta va a ser negativa 00:28:36
que es justo lo que queremos 00:28:38
si las notas de ambos son iguales 00:28:40
va a ser cero 00:28:43
y si la nota del que llama el método es mayor que el otro 00:28:43
esta resta va a ser positiva 00:28:46
luego 00:28:48
con este código 00:28:50
y con esto me da igual 00:28:51
estoy haciendo lo mismo con uno que con otro 00:28:54
lo que más os guste 00:28:56
¿vale? 00:28:58
o la línea de arriba o esto de abajo 00:29:00
es lo mismo 00:29:02
bueno, pues entonces, ya he dicho que mis alumnos 00:29:03
son comparables y además he dicho con qué criterio 00:29:08
ahora ya sort 00:29:11
quedará tranquilo, suponemos, cuando lo llamemos 00:29:12
sort ya tiene 00:29:15
un criterio para ordenarlos 00:29:16
vamos a ver si lo hemos hecho bien 00:29:18
bien, vamos a insertar tres 00:29:20
desordenados 00:29:29
esta tiene un seis, vale 00:29:30
vamos a 00:29:34
insertar 00:29:36
ya voy mal, porque he puesto 00:29:37
como nif, bueno, pero da igual, el nif le permite 00:29:44
un string también, pues da igual 00:29:46
esta 00:29:48
tiene un 6 y voy a permitir 00:29:50
otra que tenga un 1 00:29:52
y así 00:29:54
vale, pues este 00:29:55
tiene un 1, vamos a ver 00:30:02
el listado, 3 00:30:04
vale, pues bueno 00:30:06
he puesto dos notas iguales 00:30:11
estas son 00:30:13
vamos a mostrar listado ordenado 00:30:15
por nota, 4 00:30:17
bueno, parece que ordena 00:30:19
lo que pasa es que no he metido los datos 00:30:23
pero vamos, si hacéis pruebas 00:30:25
con más datos 00:30:26
efectivamente ahora ya sí que ordena 00:30:29
ahora ya sí que ordena 00:30:31
vale, pues este es un ejemplo 00:30:40
este es un ejemplo del uso 00:30:42
de la motivación, de para qué sirven 00:30:45
por qué existen las interfaces 00:30:47
las interfaces son una forma 00:30:48
de recoger comportamientos 00:30:51
a los que uno puede adherirse 00:30:54
o puede no adherirse. 00:30:55
Se adhiere si le interesa y si no, no. 00:30:57
Recogen comportamientos. 00:30:59
Despedible, comparable, es su uso habitual. 00:31:01
Recogen comportamientos. 00:31:03
Entonces, si tú te adhieres a ese comportamiento, 00:31:05
tienes que darle cuerpo a ese comportamiento 00:31:09
y decir cómo lo vas a hacer. 00:31:11
Tienes que decir cómo lo vas a hacer. 00:31:12
Y luego ya el resto del mundo, 00:31:14
como ya va a asumir que tú te has adherido 00:31:16
a ese comportamiento porque has implementado 00:31:18
la interfaz, ya podrá usarte 00:31:20
llamando a esos métodos 00:31:23
para que tú ejerzas 00:31:25
ese comportamiento, para que tú lo ejerzas 00:31:27
aquí sort 00:31:30
nosotros claro, no hemos visto lo que 00:31:31
hace por dentro sort, pero 00:31:33
aquí sort lo que 00:31:35
hará por dentro 00:31:37
en el main, lo que hará por dentro 00:31:38
sort será 00:31:41
coger cada alumno, ir uno por 00:31:42
uno, llamar al compare to para 00:31:45
aplicar su algoritmo, porque ya 00:31:47
sabe que son comparables 00:31:49
entonces llama al compare tú para compararlos 00:31:51
etcétera, cuando lo ha intentado la otra vez 00:31:53
y ha ido a llamar al compare tú 00:31:55
decía, eh, pero si estos no son comparables 00:31:56
no se han adherido a ese comportamiento 00:31:58
de ser comparables 00:32:01
por eso las interfaces 00:32:02
recogen comportamientos, uno 00:32:04
en su aplicación diseña lo que le interesa 00:32:06
las entidades que sean 00:32:09
se adhieren, yo 00:32:11
además de ser esto 00:32:12
me adhiero a esto, y a esto, y a esto 00:32:14
a todos los que quieran, separadas por comas 00:32:17
y ahora ya el resto del mundo 00:32:18
asume que yo puedo ejecutar 00:32:21
esos métodos, lo asume porque los tengo implementados 00:32:23
y me llama para ejecutarlos 00:32:25
y ya está 00:32:27
¿vale? porque yo he dicho que sí 00:32:28
que yo me comporto de esa manera y hago esas cosas 00:32:30
¿vale? 00:32:32
claro, claro 00:32:40
¿eh? 00:32:41
claro, en este caso 00:32:47
claro 00:32:48
el listado me lo ha 00:32:49
me lo ha dejado ya ordenado 00:32:52
que yo quiero mostrarlo 00:32:53
O sea, el array me lo cambia de sitio. 00:32:55
Que yo no quiero eso, podría usar un auxiliar. 00:32:58
Podría hacer esto. 00:33:01
Alumno. 00:33:03
Imagínate que hago esto. 00:33:04
Me hago aquí un auxiliar que tenga alumnos. 00:33:06
Y el que ordeno, que sea el auxiliar. 00:33:08
Y luego muestro el auxiliar. 00:33:12
Entonces, ¿vale? 00:33:17
Entonces, si yo hago esto, me ha ordenado una copia para efectos de mostrarlo. 00:33:26
Pero el repositorio sigue con su 00:33:32
Array de alumnos con el orden que tuvieran 00:33:35
¿Vale? Depende de lo que yo quiera hacer 00:33:37
¿Vale? 00:33:39
Vale, pues entonces 00:33:45
Eh... 00:33:47
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
26 de febrero de 2024 - 18:55
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
33′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
153.04 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid