Saltar navegación

20250121 Interfaz Comparable Ejemplo - 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 21 de enero de 2025 por Stefano C.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, entonces voy a grabar este ejemplo, ¿vale? A ver qué tal sale. 00:00:00
Pues me voy a crear una clase. 00:00:05
Mi clase se llamará utilidades, ¿vale? 00:00:10
Que es una clase genérica que hace cosas, ¿vale? 00:00:17
No quiero que esto sea utilidades para una clase en concreto, 00:00:22
para, oye, me hago un método para la clase gato, para la clase no sé qué. 00:00:27
Quiero que esta aquí sea una cosa más genérica, ¿vale? 00:00:31
Por ejemplo, yo quiero poder utilizar estas utilidades para que tú me digas una rey 00:00:35
y yo te ordene esta rey, por ejemplo, ¿vale? 00:00:44
O, no lo sé, empezamos desde algo más fácil. 00:00:48
Digamos, que antes me digas si una cosa es mayor o menor que... es ordenada, digamos, o que me pille dos objetos y me los ordene, me ponga antes el primero y luego el segundo, ¿vale? Una cosa de ese estilo, ¿vale? 00:00:53
Entonces, empiezo desde algo muy fácil. Entonces, public void escribe ordenados object a, object b. 00:01:11
¿Sí? Si yo hago una cosa de ese estilo, el objetivo es lo siguiente. Tú me das dos objetos. 00:01:34
y yo te pongo, esto viene antes que este otro, o este viene antes que este otro, ¿sí? 00:01:41
La pregunta es, ¿puedo hacer algo así? 00:01:49
Imaginamos que estos sean enteros, ¿sí? 00:01:56
Si yo te doy 3 y 7, pues tú sabes que 3 viene antes de 7, 00:01:59
si yo te doy 7 y 3, tú sabes que tienes que invertirlos, ¿sí? 00:02:02
Pero si yo aquí pillo objetos, ¿cómo hago a comparar este objeto con este objeto? 00:02:06
Pregunto. 00:02:13
No lo sé, porque no sé cómo se compara un objeto. 00:02:16
Hay objetos que no se pueden comparar. 00:02:19
¿Sí? 00:02:22
Entonces este object sería demasiado genérico para utilizarlo aquí. 00:02:23
¿Cómo podría hacer algo un poquito más interesante? 00:02:27
Por ejemplo, yo podría decir, oye, mira, los objetos que uso aquí no quiero que sean objetos cualquiera. 00:02:40
Quiero que sean objetos comparables. 00:02:47
no sé si tengo que importarlo 00:02:51
un objeto comparable hace referencia 00:02:58
al señor comparable 00:03:05
el señor comparable es una interfaz 00:03:08
definida, que lo que hace 00:03:18
es decir, oye mira, para 00:03:24
para poder hacer un objeto comparable 00:03:27
o sea, para que tú implementes esta interfaz, necesitas necesariamente haber creado un método compare to, ¿vale? 00:03:30
Entonces, si yo aquí utilizo comparables, sé que estos objetos tendrán dentro un compare to, ¿sí? 00:03:40
Y lo puedo utilizar. 00:03:52
Ahora, yo lo que debería hacer es leerme bien qué hace el compare to, para qué sirve, ¿vale? 00:03:53
Entonces, aquí me dice, compara los objetos con otro objeto, ¿vale? 00:03:59
Para ordenarlo 00:04:06
Y dice que, sustancialmente, puede devolver, compare tú, devuelve 00:04:07
O un número negativo, o un número cero, o un número positivo 00:04:12
Dependiendo de si el objeto es menor, igual o mayor 00:04:15
Con respecto al objeto que se compara 00:04:19
¿Sí? Vale 00:04:21
Luego explica cosas aquí, dice otra cosa, bla bla bla bla bla 00:04:23
Ahora, una cosa interesante es que hay que ver qué pasa cuando yo hago comparebol entre objetos que no son el mismo objeto. 00:04:27
Yo tengo gatos, y los gatos se comparan entre ellos. 00:04:37
Tengo string, y los string se comparan entre ellos. 00:04:40
Pero si comparo un gato y un string, ¿qué pasa? 00:04:43
Entonces, vamos a ver qué pasa. 00:04:48
Entonces 00:04:50
Este objeto, esta cosa aquí 00:04:52
Que será estático 00:04:55
Me pilla dos objetos 00:04:56
Y hemos dicho que me los tiene que escribir ordenados 00:05:00
Entonces aquí se preguntará 00:05:03
Que es este primer objeto 00:05:08
Punto 00:05:11
Fijaos que aquí son todas cosas de objetos 00:05:13
Pero también me aparece el 00:05:17
Comperto de comparable 00:05:19
Comperto B 00:05:20
¿Qué hago ahora? 00:05:23
¿Qué es esto? Un int 00:05:24
Estamos de acuerdo que es un int 00:05:28
Y tengo tres opciones 00:05:30
O es menor que cero 00:05:32
O es cero 00:05:35
O es mayor que cero 00:05:36
Si es menor que cero 00:05:37
Quiere decir que A 00:05:40
Es más pequeño que B 00:05:42
Entonces si yo escribiré 00:05:44
Si hizo A, B 00:05:48
Si hizo A, B 00:05:50
else if 00:05:55
o else 00:06:02
vamos así, porque también si son iguales 00:06:04
me da igual escribirlo al orden 00:06:09
entonces digo así, or 00:06:10
si esta cosa 00:06:12
es igual a cero 00:06:15
escribilos así 00:06:18
si no, y aquí 00:06:22
es el único caso en el que en vez 00:06:24
el número es mayor que cero 00:06:26
estrictamente mayor que cero, entonces quiere decir que 00:06:28
b es antes que a 00:06:30
pues entonces lo que tengo que escribir aquí es 00:06:32
siso B 00:06:34
y luego 00:06:37
siso A. ¿Qué no entiendes? 00:06:39
Este señor devuelve un entero. 00:06:48
El entero puede ser 00:06:50
menor que 0 00:06:51
si A es más pequeño que B. 00:06:53
Sea lo que quiera decir 00:06:57
que A es menor que B. 00:06:59
En caso de números es claro. 00:07:01
En caso de string 00:07:03
¿qué quiera decir? 00:07:05
Tenemos que saberlo. 00:07:10
Probablemente los ordenará de forma 00:07:12
lexicográfica. O sea que 00:07:13
abuelo es más pequeño 00:07:16
que zorro. 00:07:18
Porque la A es más pequeña que la Z. 00:07:20
¿Sí? 00:07:23
Probablemente. Me espero eso. 00:07:24
Si no lo sé, me lo voy a leer. 00:07:26
Ahora lo vamos a leer. 00:07:28
Asumiendo que string sea comparable. 00:07:30
Vamos a verlo después. 00:07:34
Ahora, por ejemplo, yo me hago 00:07:36
personas. Y decido que 00:07:37
las personas se ordenan 00:07:39
por edad. 00:07:41
Entonces, si A 00:07:43
es más joven que B, 00:07:45
tendré que devolver un número negativo. 00:07:47
Si B es más... 00:07:50
Si A es mayor que B, 00:07:52
o sea, más viejo, 00:07:55
pues entonces es un número positivo. 00:07:57
Y si tiene la misma edad, cero. 00:07:58
¿Sí? 00:08:02
Ahora, yo no lo sé cómo se comparan dos objetos, 00:08:02
pero sé que esto, 00:08:05
sea como sea que tú has decidido 00:08:07
que se comparan dos objetos, 00:08:09
me los dará con un número menor de cero, 00:08:10
igual o cero. 00:08:13
Entonces, si he dicho que si A es menor que B, 00:08:15
Antes me escribes A y luego B. 00:08:17
Y también si son iguales, me da igual escribir uno o el otro. 00:08:19
En el caso, en vez de que A sea mayor que B, entonces para ordenarlos, antes el menor, luego el mayor, 00:08:23
quiere decir que antes escribo el menor y luego el mayor. 00:08:29
Y fijaos, esto yo lo he hecho asumiendo que hay dos comparables. 00:08:34
No sé cómo se comparan y no sé qué objetos voy a utilizar. 00:08:39
Pero ahora tengo un método que le doy dos objetos cualquiera 00:08:43
y él decide cuál es menor y cuál es menor y me lo escribe ordenado. 00:08:46
Vamos a utilizar esto. 00:08:52
Clase principal, hago un main. 00:09:02
Y por ejemplo, dos objetos. 00:09:11
Integer x es igual a 5. 00:09:17
Integer y es igual a... 00:09:23
Es igual a 9. Cuidado. Esto debería ser new integer. Pero es que no le gusta. O sea, Java hoy en día hace una conversión automática entre tipos primitivos y tipos que representan ese tipo primitivo como objeto. 00:09:28
Esto es un objeto 00:10:00
Un objeto de la clase integer 00:10:01
Pero cuando lo escribo así, él en automático lo que hace es que me pilla 5 como entero 00:10:03
Y me lo guarda dentro de un objeto que representa el número 5 como entero 00:10:07
Porque yo int s es igual a 5, a 4 00:10:16
Y yo no puedo hacer ese punto 00:10:22
Porque no puedo hacer métodos o variables sobre el entero como tipo primitivo 00:10:24
Sin embargo, sí que puede hacer x punto, porque es un objeto y tendrá sus métodos. 00:10:31
Tiene métodos que me pueden dar valor, tiene métodos que me puede saber cuánto es largo, muchas cosas, 00:10:36
incluido este de aquí, que a lo mejor lo conocemos de algo. 00:10:43
Entonces, integer implementa comparable. 00:10:50
No lo sé. Vamos a verlo. 00:10:58
que hay un buscador aquí 00:11:01
entonces me voy a buscar integer 00:11:04
api, java 00:11:09
me voy a mirar 00:11:11
integer 00:11:13
y voy a mirar si por ejemplo 00:11:14
implementa 00:11:17
comparable, ahora tiene una 00:11:19
cosa rara aquí, que todavía 00:11:21
no sabemos bien que es, lo veremos 00:11:23
vale, pero 00:11:25
comparable la implementa 00:11:27
y de hecho 00:11:29
si voy a mirar los métodos que puede hacer 00:11:31
está el compare to 00:11:33
¿Sí? Pues, por ejemplo, yo lo que puedo hacer ahora es utilizar mi utilidades, punto, escribe ordenados, x y, y voilà, me lo has escrito ordenado. 00:11:35
Si yo le cambio el valor y lo llamo otra vez, ¡bam!, me lo escribió ordenado. 00:12:03
Es capaz de ordenarme estos objetos porque estos objetos son comparable. 00:12:11
¿Vale? 00:12:19
Cambiamos de objeto. 00:12:20
String a es igual a vuelo. 00:12:22
String b es igual a gato. 00:12:30
Sí, para algo. 00:12:35
Pues sí, ahora puedo utilizar esta cosa de aquí, entre A y B. 00:12:37
Siempre y cuando, si tengo suerte, string, 00:12:51
resulta que implemente, all implement interface, fíjate tú, comparable. 00:12:58
Por lo tanto, tiene un compare to, por algún lado, 00:13:08
y aquí encontraré un compare to. 00:13:13
Y si voy a mirar el compareTo, aquí me dice cómo se ha implementado el compareTo para string. 00:13:15
Y me dice compares two strings lexicográfically, o sea, ordenadas alfabéticamente, ¿vale? 00:13:23
Entonces, me espero que tengo abuelo y gato, me escriba abuelo y gato. 00:13:31
si tengo 00:13:37
zabuelo 00:13:40
y gato 00:13:43
pues me escribirá 00:13:45
gato y zabuelo 00:13:47
y fijaos, yo no he cambiado este método 00:13:48
este método me está valiendo para entero 00:13:53
me está valiendo para string, me está valiendo 00:13:57
para cualquier 00:13:58
objeto que exista 00:14:00
que implemente con parable 00:14:02
me funciona 00:14:05
mi método, ¿me entiendes? 00:14:07
ahora 00:14:12
La pregunta es 00:14:12
¿Qué pasa? 00:14:14
Mi amigo 00:14:33
Cast class exception 00:14:34
Porque claro, ¿qué intenta hacer él? 00:14:37
Él le dice, pongo y pillo un entero 00:14:40
Si os acordáis, hacía esto 00:14:41
Punto compares to esto 00:14:44
Pero claro, este de aquí 00:14:46
No es un tipo compatible 00:14:48
Con integer 00:14:50
Estoy haciendo un integer en string 00:14:51
¿Qué viene antes? ¿Tres o abuelo? 00:14:53
No tengo ni idea, no son comparables 00:14:56
Entonces Java, cuando hace una cosa de ese estilo 00:15:00
Pues explota con una excepción 00:15:03
¿Por qué explota con una excepción? 00:15:06
Porque si yo me voy a mirar aquí 00:15:07
Comparable, ¿vale? 00:15:09
Aquí, además de otras cosas, por algún lado 00:15:13
Me comenta que Compar2 puede lanzar dos cosas 00:15:16
o null pointer exception 00:15:23
si es que tú me has dicho 00:15:25
este punto compare tú 00:15:29
y como parámetro me has dado un null 00:15:32
entonces como no puede él trabajar con este null 00:15:35
pues lo que hace es explota con un null pointer exception 00:15:39
si el objeto especificado es null 00:15:42
lanza un null pointer exception 00:15:45
si el objeto especificado 00:15:47
el tipo del objeto especificado 00:15:50
no puede ser comparado con este 00:15:52
objeto, con this 00:15:55
pues entonces lanza un class 00:15:56
cast exception, o sea te lo dice 00:15:59
aquí como tiene que ser implementado 00:16:01
si tú 00:16:03
haces una implementación 00:16:05
del compares to 00:16:06
y resulta que no son 00:16:08
compatibles 00:16:12
lo que debería hacer tu programa 00:16:14
compares to es lanzar 00:16:16
un class cast 00:16:18
exception 00:16:20
entonces y hasta aquí utilizando cosas que me han dado ya hecha vale pues vamos a hacer nuestra 00:16:21
propia clase vamos a hacer una clase nueva que es la clase algo que se pueda comparar persona 00:16:35
y comparamos las edad 00:16:50
tenéis otra 00:16:52
persona 00:16:54
la clase persona tiene 00:16:57
string nombre 00:17:00
e int edad 00:17:03
tiene un constructor 00:17:06
que me permite crear una persona 00:17:09
y luego queremos que esta persona 00:17:21
se pueda comparar 00:17:25
fijaos que si ahora voy aquí 00:17:26
y digo vale creamos dos personas 00:17:28
persona p1 00:17:30
p es igual 00:17:32
pers 00:17:33
1 es igual a 00:17:35
new persona 00:17:38
Sara 00:17:39
y persona 00:17:48
pers 2 00:17:51
es igual a new persona 00:17:53
paco 00:17:56
coma 00:18:02
y ahora le digo 00:18:04
utilidades 00:18:10
punto 00:18:12
escribe 00:18:14
utilidades 00:18:15
pers 1 00:18:16
pers 2 00:18:17
se enfada 00:18:20
¿por qué se enfada? 00:18:23
¿por qué me he enfadado? 00:18:37
porque persona 00:18:43
no es de tipo comparable 00:18:44
no es un comparable 00:18:46
¿por qué? 00:18:51
porque todavía no he extendido 00:18:51
no he implementado comparable 00:18:53
y yo he dicho 00:18:55
que utilidades 00:18:57
lo que hace es pillar un comparable 00:18:58
Entonces persona no lo puede hacer 00:18:59
Así como tal 00:19:02
No puedo implementar 00:19:03
Ah, espera, no pasa nada 00:19:05
Public 00:19:06
No, int 00:19:10
Compare to 00:19:11
The object 00:19:14
Object 00:19:17
Ya está 00:19:18
Ya tengo para comparar 00:19:20
Return 1 00:19:22
Ya está, ya lo tengo 00:19:24
¿Por qué se enfada? 00:19:26
Porque el hecho que yo implemente 00:19:40
Este método no quiere decir que esté implementando la interfaz. 00:19:42
¿Se entiende? 00:19:49
O sea, yo no he sobrescrito el contrato. 00:19:51
O sea, no he firmado el contrato. 00:19:55
¿Vale? 00:19:58
La gente desde fuera ve que persona sí tiene un compare to, 00:19:58
pero no es el compare to definido en la interfaz comparable, 00:20:02
porque yo no la implemento esa interfaz. 00:20:06
por lo tanto no puedo 00:20:08
tratar a una persona como 00:20:10
comparable, lo que estoy haciendo 00:20:11
es que tú tienes tu método compare to 00:20:14
tuyo, que lo has usado como te da la gana 00:20:16
para que 00:20:18
yo esté seguro 00:20:20
que esto funcione 00:20:21
pues entonces le tengo que 00:20:24
decir implement 00:20:26
comparable 00:20:27
ahora, este 00:20:30
comparable aquí, ahora yo he 00:20:32
firmado el contrato, que no es un 00:20:34
Compartoo como me da la gana 00:20:36
Es el Compartoo de Comparable 00:20:38
Y yo tendría que 00:20:40
Irme a 00:20:42
La interfaz Comparable 00:20:43
Y leerme bien que quiere 00:20:45
Que haga la interfaz Comparable 00:20:48
Y definir 00:20:51
Esto 00:20:52
¿Está claro? 00:20:53
Vale 00:20:56
Ahora, si yo lo he hecho 00:20:56
Sé que Comparable 00:21:00
Tiene que comparar 00:21:02
this con este 00:21:04
objeto de aquí 00:21:06
¿vale? y 00:21:07
ver 00:21:09
si son compatibles o no 00:21:10
¿sí? entonces 00:21:13
lo voy a hacer de una forma un poquito rara 00:21:15
pero ve, la primera cosa 00:21:18
es que este objeto de aquí 00:21:20
tiene que ser 00:21:22
una persona, si no 00:21:23
mal vamos, yo estoy en 00:21:29
persona, estoy comparando 00:21:32
this que es una persona 00:21:35
y no lo quiero comparar con un gato 00:21:36
Porque no puedo comparar gato. Si yo te digo, ¿qué viene antes? ¿Esta persona aquí que he creado? ¿Esta persona aquí? ¿Esta? ¿O la palabra abuelo? No lo sé, no son comparables. 00:21:38
Entonces, si yo estoy definiendo una forma de comparar entre ellos dos señores, dos personas, ¿vale? 00:21:57
Entonces, lo que necesito es que esto también sea una persona. Necesito dos personas para poderlas comparar. 00:22:06
Una es... ¿Cuáles son las dos personas que estoy comparando? 00:22:13
No. Aquí no está ni persona 1 ni persona 2. ¿Quién son? 00:22:23
Porque aquí yo lo he llamado así 00:22:31
Pero si ahora le pongo persona 3, persona 4 00:22:36
Es una cosa distinta 00:22:39
No lo sé, no sé qué voy a... 00:22:40
Aquí estoy en general 00:22:42
Pero aquí yo tengo dos objetos con los que puedo trabajar 00:22:44
¿Cuáles son estos objetos? 00:22:47
Uno es esto 00:22:55
Este es un objeto 00:22:56
¿Sí? ¿Y cuál es el otro? 00:23:00
¿Y cómo se llama la referencia de ese mismo objeto? 00:23:12
This 00:23:15
Estos son los dos objetos que estoy comparando 00:23:15
This 00:23:18
Y el objeto que me han pasado por parámetro 00:23:19
¿Sí? 00:23:22
Ahora, this es una persona 00:23:23
¿Por qué? Porque estoy en la clase persona 00:23:25
This es una persona, ningún problema 00:23:27
Pero object 00:23:29
¿Qué es? 00:23:31
Por eso, entonces necesito 00:23:33
Cerciorarme que esto sea 00:23:43
Una persona, ¿cómo lo hago? 00:23:45
¿Qué puede pasar aquí? 00:24:06
Dos cosas 00:24:08
Uno 00:24:09
Que object 00:24:11
sea una instancia de persona 00:24:16
o sea que si hiciera 00:24:19
obj instance of persona 00:24:21
me diera true 00:24:23
y entonces esta cosa funciona perfectamente 00:24:24
¿verdad? 00:24:28
o la segunda opción 00:24:31
que si yo hiciera 00:24:32
persona 00:24:33
p instance of persona 00:24:35
me devolviera un 00:24:38
hola 00:24:39
me devolviera un 00:24:41
un class cast exception 00:24:44
que si os acordáis 00:24:47
el compare to puede lanzar 00:24:49
un class exception 00:24:51
si está mal, por lo tanto esto me viene perfecto 00:24:53
yo lo hago 00:24:56
que son 00:24:57
tipos compatibles, ya lo he transformado 00:24:59
a una persona y ahora tengo dos personas 00:25:01
que no son tipos compatibles 00:25:03
pues lanzará un class exception 00:25:05
que es lo que se espera en la gente 00:25:06
del método 00:25:09
compare to, la gente 00:25:10
según el contrato, este es mi 00:25:13
contrato, se espera que 00:25:15
si el tipo del objeto 00:25:17
que te ha dado no es compatible, 00:25:19
tú lances un class case exception. 00:25:21
Pues ya está. 00:25:24
Ya lo tengo. 00:25:26
¿Se entiende? Pero yo quiero que me salte. 00:25:29
El contrato del 00:25:37
compertú me dice que si tú aquí 00:25:39
me pasas un objeto que no es 00:25:41
persona, tú tienes que hacer 00:25:43
saltar un error. Lo dice aquí. 00:25:45
Lo dice aquí. 00:25:49
Si el tipo del objeto especificado, o sea, el que pasa los parámetros, 00:25:51
no puede ser comparado con este objeto, o sea, porque son tipos distintos, 00:25:56
me lanzas un class cast exception. 00:26:01
Entonces, si yo voy a, como no sé todavía cómo lanzar excepciones, 00:26:04
pues lo que voy a hacer es aprovecharme de esto. 00:26:10
Yo sé que esta cosa de aquí, si la hago mal, si este de aquí no es una persona, 00:26:12
Cuando lo hace, lanza un classCastException 00:26:17
Por lo tanto, con esta frase aquí 00:26:20
Yo puedo tener dos resultados posibles 00:26:22
O el objeto que me has pasado es una persona 00:26:25
Y por lo tanto ahora lo tengo referenciado como persona 00:26:28
Y puedo usar los métodos de persona 00:26:30
Perfecto 00:26:32
O el objeto que me has pasado no es una persona 00:26:34
Y cuando intento castearlo a algo que es persona 00:26:36
Me va a lanzar un classCastException 00:26:39
Te mueves aquí, por favor 00:26:41
Te mueves aquí 00:26:43
¿Me entendéis? 00:26:47
¿Vale? Entonces, aquí yo estoy aprovechando 00:26:53
La funcionalidad de otra cosa 00:26:56
Que es el cast, que a veces lanza 00:26:57
Un classCastException para poder 00:26:59
Completar mi 00:27:01
Trabajo 00:27:03
Con este de aquí 00:27:05
¿Vale? Entonces, ahora yo tengo 00:27:07
Dos personas, aquí, aquí delante 00:27:09
Ahora tengo dos personas, ¿qué hago? 00:27:11
Tengo dis 00:27:16
Y tengo p 00:27:17
¿Vale? Lo que quiero hacer yo 00:27:18
es, para hacerlo básico, interresultado es igual a cero, por ejemplo, si this.edad, hemos dicho que comparamos por edad, es menor que p.edad, 00:27:21
Entonces, ¿qué hago? 00:27:42
Si this es más pequeño que p 00:27:59
Devuelvo 00:28:03
No estoy en escribir ordenado 00:28:04
Estoy en comparando 00:28:12
Yo tengo que decir si este es más grande o más pequeño 00:28:14
Y para decir que es pequeño mando un número negativo 00:28:16
Para decir que son iguales un cero 00:28:20
Para decir que es mayor un número positivo 00:28:22
Por lo tanto, menos uno 00:28:26
Si this es más joven que p, entonces te daré menos uno. 00:28:28
Else o if otra vez. 00:28:40
Lo hago feo porque luego vemos que hay otro. 00:28:44
This.edad es mayor que p.edad. 00:28:47
Resultado, uno. 00:28:54
Y ya está. 00:28:59
Return, resultado. 00:29:00
Si son iguales 00:29:02
Ya la he metido a cero 00:29:06
Entonces no entrará ni aquí ni aquí 00:29:07
Y me lo dejará en cero 00:29:09
Pues ya está, he definido 00:29:11
Cómo se comparan estas dos personas 00:29:14
Vamos a ver 00:29:17
En principal 00:29:19
Ahora tengo mis dos personas 00:29:23
Que ahora son comparable 00:29:25
Y por lo tanto sí que los puedo poner aquí 00:29:27
En este caso me debería dar 00:29:29
Antes Sara y luego Paco 00:29:32
Y me da 00:29:34
¿Por qué? 00:29:35
Porque no he definido cómo se escriben las personas. 00:29:43
Entonces, public string toString. 00:29:47
Cuando quieres dar una representación en formato string de estos objetos, es el toString. 00:29:54
Lo que haces es, por ejemplo, return this.nombre más una paréntesis, 00:30:01
más this.edad 00:30:15
más cierro paréntesis 00:30:17
entonces la representación de un objeto persona 00:30:19
será su nombre seguido de entre paréntesis 00:30:23
su edad 00:30:26
ahora cuando lo lanzo aquí 00:30:27
veo que me lo ha ordenado como Sara 00:30:30
que tiene 33 años y luego pago de 44 00:30:33
si pago lo pongo 00:30:36
de 14 años 00:30:37
pago y Sara 00:30:39
o sea que yo he definido 00:30:43
Cómo se comparan entre ellos dos personas 00:30:47
Y a partir de allí 00:30:51
Él me los ordena correctamente 00:30:54
¿Se entiende? 00:30:58
Fijaos que yo me espero también 00:31:02
Que este método de aquí 00:31:04
Bueno, el método compare to 00:31:05
Si por si acaso y aquí le pongo 00:31:06
Que es un entero 00:31:10
Pues esto debería explotar con un 00:31:12
ClassCastException 00:31:15
perfecto, classCastException 00:31:19
¿por qué? porque cuando llegará aquí 00:31:22
e intenta hacer del integer 00:31:25
una conversión a persona 00:31:27
pues esto no es correcto 00:31:30
y por lo tanto lanzará un classCastException 00:31:32
me vale 00:31:34
y por otro lado 00:31:36
si yo aquí le paso un null 00:31:39
me debería dar un null pointer exception 00:31:42
¿Por qué? Porque cuando dentro de persona intentará hacer P.edad 00:31:49
P es null 00:31:55
Y por lo tanto null.edad me dará un null pointer exception 00:31:57
¿Dudas hasta aquí? 00:32:02
Vale, ahora 00:32:07
Si os fijáis 00:32:08
Esto compara dos personas 00:32:10
Y me dice si es menor o igual o mayor de edad 00:32:14
¿Sí? 00:32:18
Pero no me dice cuánto 00:32:19
O sea, independientemente de que uno sea de una edad y uno sea de otra, me dará menos uno. Uno o cero. 00:32:21
Y funciona. Está definido. ¿Vale? Por cómo está definido compertú, me vale. 00:32:31
Pero compertú podría ser más fino, hilar más fino, y decirme en este int cuánto es menor o cuánto es mayor con respecto al otro objeto. 00:32:38
O sea, que en vez de devolverme menos 1, 0 y 1, me podría, si los dos están cerquita, devolverme menos 1, por ejemplo, pero si los dos son muy lejos, pues devolverme menos 100. 00:32:53
Y si los dos son muy, muy lejos, menos 1000. 00:33:05
Por ejemplo, aquí podría hacer dis.p menos, dis.edad, perdón, menos p.edad. 00:33:10
porque si esto tiene 10 y esto tiene 20 00:33:32
me dará un número negativo 00:33:40
y es como tiene que ser 00:33:42
si esto tiene 20 y esto tiene 10 00:33:45
me dará un número positivo 00:33:47
y si esto tiene la misma edad me dará 0 00:33:48
perfecto 00:33:51
¿si o no? 00:33:53
por lo tanto 00:33:57
esta podría ser una solución 00:33:58
es más 00:33:59
si esto tiene 10 años y esto tiene 40 00:34:00
me dará menos 30 00:34:03
y me está dando 00:34:06
más distancia con respecto a 00:34:08
si esto tiene 10 y esto tiene 12 00:34:10
que me dará menos 2 00:34:12
entonces el número que me da, no solo me dice 00:34:13
positivo o negativo, que es lo que 00:34:16
para que sirve Compertur 00:34:18
sino que también lo puedo utilizar 00:34:20
para saber cuánta distancia hay entre ellos 00:34:22
que a lo mejor para otros 00:34:24
otros trabajos 00:34:26
pues puede venir bien 00:34:28
¿sí? y fijaos que 00:34:29
esta implementación, aparte que es más elegante 00:34:32
que todo este iffeo 00:34:34
pues sigue funcionándome 00:34:36
sigue funcionando 00:34:39
aquí 00:34:46
si, fijaos el método es siempre 00:34:47
el mismo, da igual 00:34:54
que objetos le estoy pasando 00:34:56
con que implementen 00:34:58
comparable tendrán 00:35:00
dentro el método compareTo 00:35:02
por lo tanto independientemente 00:35:04
de lo que sea comparable tendrá 00:35:06
el compareTo y lo podré utilizar 00:35:08
sobre estos objetos y por lo tanto 00:35:10
podré definir 00:35:12
este método y podré utilizar 00:35:14
este método, ahora esto extendiéndolo 00:35:16
en vez de escribir ordenados 00:35:19
yo lo que podría hacer aquí es 00:35:21
pillar un array 00:35:22
de comparable 00:35:24
y ordenarlo 00:35:26
independientemente de lo que esté 00:35:28
a lo que estoy ordenando 00:35:30
vale 00:35:32
si yo me voy 00:35:33
a Arrays 00:35:35
en Arrays, si no me equivoco 00:35:39
estará 00:35:46
este señor de aquí 00:35:52
en sus varias funciones 00:35:54
este de aquí es un array sort 00:35:57
¿vale? 00:36:00
por algún lado 00:36:02
no, no, hay un sort 00:36:04
de comparable, no 00:36:06
hay un sort de object 00:36:08
pero bueno, a ver como lo hace 00:36:11
yo podría hacerme, pensaba de encontrarlo 00:36:15
aquí, pero podría hacerme un 00:36:18
ordena 00:36:19
de objetos comparable 00:36:21
y luego allí dentro ir comparándolo 00:36:23
entre ellos y si están desordenados 00:36:26
ordenarlos hasta que tenga 00:36:28
un array ordenado y lo devuelva 00:36:30
¿vale? y esto es un ejercicio parecido 00:36:32
a lo que hacíamos en octubre 00:36:34
de dado un array desordenado 00:36:36
ordenalos, solo que en vez 00:36:38
de ordenarlos según los 00:36:40
números, lo ordeno según lo que me 00:36:42
dice el 00:36:44
el Compertú 00:36:45
¿sí? 00:36:47
o sea que esto lo podéis hacer 00:36:49
¿sí? 00:36:51
y más cosas que yo 00:36:55
quería hacer con esto 00:36:57
vale, entonces 00:36:59
Si todo esto está bien, ahora yo puedo hacer lo siguiente, ¿vale? 00:37:14
Yo podría hacer siso persona.perts1.compareto.perts2, ¿sí? 00:37:19
Y también puedo hacer siso persona.equals.perts2. 00:37:37
¿Sí? Entonces, si eso es que persona 1 y persona 2 son distintos, ¡voilá! 00:37:46
Me está diciendo que hay una diferencia de edad de 19 años y que no son lo mismo. 00:37:54
¡Fenomenal! 00:37:59
Pero cuidado. Y si yo le digo que los dos tienen 14 años, con pertú me dicen que son iguales. 00:38:01
Sin embargo, ¿eh? ¿Cuál se me dice que son distintos? 00:38:14
Y esto no puede ser. Es mi responsabilidad cuando implemento la clase Persona, que implementa Comparable, y entonces hago esta cosa de aquí, yo tengo que estar seguro que ahora cuando me da cero, los dos son iguales. 00:38:17
¿Se entiende? Pues ¿cómo hago eso? Tendré que redefinir equals porque según mi concepto de comparación, para mí dos personas son iguales cuando dos personas son mayores o menores según la edad. 00:38:38
Entonces, tendré que definir de alguna forma que cuando estas dos personas, mejor, cuando estas dos personas sean iguales, no puedan ser distintos esta cosa aquí, el compertú. 00:39:00
O sea que aquí hay que razonarlo un poquito mejor. Porque esto me podría valer asumiendo que mi concepto de equals, de igualdad, tenga en consideración también el nombre. 00:39:17
O sea, estos señores no son la misma persona, porque uno es sara y uno es pajo, tienen la misma edad. 00:39:34
Entonces, si los comparo son iguales, pero es justo que no sean la misma persona. 00:39:43
A menos que para mí dos personas de la misma edad sean la misma persona. 00:39:49
Pero si yo ahora hago esto, y yo considero que estos dos sean la misma persona, deberían ser equivalentes, 00:39:53
pues entonces esto ahora me debería dar true. 00:40:04
No sé si me explico lo que quiero decir, ¿vale? O sea, que yo cuando toco el compare to, tengo que pensar también a cómo identifico el equals. Las dos cosas van juntas y tienen que ser consistentes, ¿vale? 00:40:07
Si para mí dos personas son iguales cuando tienen nombre y edad iguales, que es una definición de igualdad un poco blanda, porque nosotros sabemos que dos personas se pueden llamar Sara y dos personas pueden tener 14 años, pero por cómo lo estoy haciendo yo, dos objetos Sara 14 deberían ser el mismo. 00:40:25
Si yo quiero poderlo separar, a lo mejor le pongo un identificador, a lo mejor le pongo el DNI, entonces sí que sé cuándo son iguales, cuándo no, ¿vale? 00:40:45
Pero COMPARE TO e EQUALS deberían estar consistentes entre ellos, sobre todo si dos personas son la misma persona, el resultado de COMPARE TO tiene que ser cero, sí o sí. 00:40:55
Y que si compareTo da un valor que no es cero, pues probablemente los objetos no deberían ser el mismo objeto. 00:41:12
Estas dos cosas hay que comprobar. 00:41:25
Entonces, en este caso aquí, pues debería yo pensar también en cuando hago, como norma general, 00:41:28
cuando hago la implementación de comparable o entonces compareTo, 00:41:35
pues va en pareja también sobre escribir el equals 00:41:39
para que sean consistentes los resultados de comparable 00:41:42
y de equals, y esto por algún lado dice 00:41:46
esto, yo creo que aquí no 00:41:48
mira 00:41:55
he recomendado muchísimo 00:42:08
pero no requerido 00:42:15
estrictamente, que si 00:42:18
x convertido de y da 0 00:42:21
entonces 00:42:23
x.equals de y 00:42:25
te de true 00:42:28
constantemente 00:42:30
luego 00:42:31
habrá casos en que tú dices 00:42:35
no, no puede ser y quiero que no 00:42:37
pero por lo general 00:42:39
esto debería ser una cosa que funcione 00:42:41
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
16
Fecha:
21 de enero de 2025 - 12:40
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 49″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
158.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid