Saltar navegación

20250127 InterfacesComparable_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 29 de enero de 2025 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Dando. 00:00:00
Que no han operado a nadie 00:00:02
de fomosis, hombre. 00:00:04
No, no la voy a parar. 00:00:07
Me da igual. 00:00:09
Venga, proyecto. 00:00:18
Este, antes de hacer un ejercicio 00:00:23
grande que vais a hacer vosotros, 00:00:26
Este es un proyecto pequeño, cortito, 00:00:27
para que os creáis que esto de las interfaces realmente se usa 00:00:32
y mola. 00:00:35
¿Vale? 00:00:36
Vale. 00:00:37
Ahora vale. 00:00:38
No, es que es así. 00:00:41
Porque sois unos sosos y unos parados y unos desaborigos. 00:00:42
Y no os emocionáis con nada. 00:00:46
Pues ahora vais a emocionar. 00:00:50
Suéltame. 00:00:51
Suéltame. 00:00:52
Sigue, sigue. 00:00:53
No se lo pasa nada. 00:00:53
Y luego la denuncia. 00:00:54
Venga, denúnciame a ver qué pasa. 00:00:57
Lo voy a llamar proyecto ejemplo 00:01:03
comparable. Comparable ya no suena 00:01:05
al nombre de interfaz. 00:01:07
Muchos se acaban en hable. 00:01:09
Pues, proyecto ejemplo 00:01:11
comparable. Fíjate. 00:01:13
Eso no suena. 00:01:16
Venga, proyecto ejemplo comparable. Vale. 00:01:19
Pues, voy a hacer aquí un paquetín. 00:01:23
pues vamos a 00:01:27
hacernos 00:01:30
una clase 00:01:31
para trabajar con 00:01:34
¿qué queremos trabajar? 00:01:36
con alumnos, con mesas 00:01:38
¿con qué queremos trabajar? 00:01:40
con clases 00:01:41
con hormigas 00:01:43
con 00:01:45
una entidad cualquiera 00:01:46
de cualquier cosa, venga, rápido 00:01:49
sí 00:01:51
bebidas 00:01:53
yo no entiendo de eso 00:01:55
Pues no te quiero en mi clase 00:01:56
Venga 00:02:00
No, no, estoy haciendo 00:02:01
Un proyecto aparte 00:02:04
Cuya única función 00:02:06
Va a ser ver un ejemplito de uso 00:02:09
De interfaces que nos haga 00:02:11
Entender 00:02:12
El sentido que tiene esto 00:02:13
Bueno, pues entonces 00:02:15
Nuestras casitas 00:02:21
¿Por qué se van a distinguir? 00:02:23
Por la dirección 00:02:28
Sin tilde 00:02:30
Hacer posible 00:02:31
Dirección completa 00:02:33
Y cualquier chorrada por hacer algo 00:02:36
Venga 00:02:39
Completa 00:02:40
No, dirección completa y cualquier chorrada de la casa 00:02:45
Y el colorcito que tenga la casa 00:02:49
Bueno, no, y la fecha en la que la compramos 00:02:50
Que nos gusta mucho 00:02:53
hala, ya está, venga 00:02:54
entonces 00:02:56
callad que os pongo un char 00:02:57
venga, pues vamos a hacer 00:03:02
unos constructores 00:03:10
muy monos 00:03:12
y un getter 00:03:14
y un set 00:03:18
esto es lo que mejor os sale, ¿verdad? 00:03:19
con el loguete y el setter y el constructor. 00:03:23
¿Ya ha aparecido tu monitor? 00:03:26
Sí, sí, ya está. 00:03:28
Vale. 00:03:29
Vale. 00:03:30
Pues ahora vamos a hacer nuestro main que trabaja con casas. 00:03:33
Venga. 00:03:42
Ahora nuestro main que va a trabajar con casitas 00:03:46
para hacer cosas con un montón de casitas. 00:03:48
Y estas casitas 00:03:50
las vamos a meter, pues, ¿dónde? 00:03:51
En un array. 00:03:54
¿Dónde las vamos a meter si no es en un array? 00:03:56
Y si es que no tenemos opción a ninguna otra cosa 00:03:58
Ay sí 00:04:00
Sufro mucho, pero es que Estefano se resiste 00:04:09
Porque le encanta hacer todo con Arraiz 00:04:12
Entonces se resiste y se resiste 00:04:14
Pero le he convencido 00:04:15
Para que adelantemos colecciones a excepciones 00:04:17
Estefano es muy pesado 00:04:20
ese es mi argumento 00:04:28
no, que es una broma 00:04:30
que no, es 00:04:32
es un pesado 00:04:34
haciéndoos aprender 00:04:36
venga 00:04:37
a ver 00:04:40
venga 00:04:41
vale 00:04:44
pues entonces, por ejemplo 00:04:46
a lo mejor 00:04:47
algo de lo que querríamos hacer 00:04:49
con estas casas 00:04:52
sería un método que las 00:04:53
nos las mostrara por orden alfabético 00:04:56
de ubicación 00:04:58
por ejemplo 00:04:59
porque lo voy a usar solo desde el main 00:05:01
este main 00:05:17
vale, entonces 00:05:18
pues nosotros aquí 00:05:25
este método 00:05:27
pues ya está 00:05:30
lo querremos llamar 00:05:31
para mostrar 00:05:34
nuestras casitas ordenadas 00:05:36
por orden alfabético 00:05:38
a ver, le voy a meter unas cuantas 00:05:38
por, vale, voy a meter unas cuantas 00:05:41
¿qué hago? 00:05:53
si llevamos la cualidad alfabética 00:06:05
claro, entonces 00:06:07
casas de i igual, una nueva casa donde la dirección 00:06:13
vamos a generar aleatoriamente el primer carácter 00:06:21
vamos a ver 00:06:24
a ver, que ya tenemos 00:06:28
wifi, por lo menos 00:06:29
ya no necesito la wifi de aquí 00:06:31
yo sí 00:06:33
vosotros no sé 00:06:37
pero que más os da 00:06:38
si tenéis todos los datos definitivos 00:06:43
iba a decir infinitos 00:06:46
porque tenéis unos padres 00:06:47
que os mantienen 00:06:49
bueno, vale 00:06:50
Ay, Dios mío. 00:06:52
Venga, pues entonces 00:07:00
esto era... 00:07:01
Es verdad, vosotros sois 00:07:04
de una casta un poco más privilegiada. 00:07:05
Sois serios, sois responsables. 00:07:08
Venga, a ver, yo quería... 00:07:11
¿Para qué quería yo la Wi-Fi? 00:07:12
¿Qué ha dicho? 00:07:16
Que es latinoamericano, que probablemente 00:07:17
no tenga padre. 00:07:18
Ah, bueno, te habrán abandonado, te habrán tirado por ahí 00:07:20
Por las calles de Bogotá, ¿no? 00:07:22
A ver, todo esto venía 00:07:29
porque yo quería generar aleatoriamente 00:07:34
un carácter. 00:07:36
Creo que padre tenemos todos. 00:07:42
Yo me considero no binario. 00:07:46
vale, del 65 al 90 00:07:48
van los caracteres 00:07:56
voy a crear aleatoriamente 00:07:58
un nombre, porque para que luego el orden se vea 00:07:59
entonces 00:08:02
del 65 al 90 00:08:03
más random 00:08:05
para generar del 65 al 90 00:08:08
90 menos 65 00:08:09
¿cuánto es? 00:08:12
es unos 25 aproximadamente 00:08:13
pues entonces multiplico esto por 25 00:08:15
le hago el casting entero y le sumo 65 00:08:18
¿verdad? 00:08:20
esto ya lo hicimos 00:08:23
sí, para, porque esto me lo dará en decimal 00:08:24
entonces 00:08:26
le hago el casting de más random por 25 00:08:27
y luego a todo esto 00:08:30
le sumo 65 00:08:32
y con eso genero un primer carácter aleatorio 00:08:33
a todo esto 00:08:36
ahora ya le sumo 65 00:08:39
Un carácter aleatorio entre 0 y 25, pero con cifras decimales. 00:08:44
Le trunco la parte decimal, le sumo 65, con lo cual ya me dará uno aleatorio entre 65 y 90 aproximadamente, que es lo que quiero. 00:08:51
Vale, ese será el primer carácter y ahora este primer carácter lo voy a concatenar ahora ya con cualquier cosita. 00:09:00
Casita. 00:09:08
Vale, y el otro... 00:09:09
Bueno, pero vamos a ver ahora cómo se ha generado. 00:09:12
Y casita, además, ¿qué otra propiedad tenía? La fecha. 00:09:19
Vale, pues un objeto date con la fecha de hoy yo creo que lo puedo generar 00:09:23
a través de un método estático de la clase date, me parece, ¿no? 00:09:30
Sí, hay que tener la fecha de hoy. 00:09:34
Local date. 00:09:37
Sí, pero local date le tengo que dar un local date que no sé. 00:09:38
yo creo que con new date 00:09:44
con new date ya directamente 00:09:47
te instancia un objeto date con la fecha de hoy 00:09:49
yo creo 00:09:52
yo sé que había uno que te devolvía 00:09:52
automáticamente la fecha 00:09:53
a darle un instante 00:09:54
sí, pero es que eso es lo que he puesto 00:09:57
entonces tienes que guardar 00:10:00
el new date en una variable 00:10:04
y eso es una variable que te va a dar 00:10:05
pero si ya esto es un date 00:10:06
entonces new date 00:10:09
vale 00:10:12
el constructor date 00:10:15
de java útil está indefinido 00:10:21
vale, vale, es que me ha importado el automático 00:10:23
no, es que me lo ha importado el solo, listo 00:10:27
vale 00:10:29
venga, pues ya lo tengo 00:10:30
las casas creadas, vamos a 00:10:33
mostrarlas primero 00:10:35
vamos a hacernos 00:10:36
vamos a hacernos un 00:10:44
tuestrin en casa, la primera 00:10:46
cosa que nos pide aquí el cuerpo 00:10:48
vamos a hacernos un toString para poner directamente 00:10:49
esto 00:10:52
¿verdad? 00:10:53
genial, pues iréis sobraos 00:10:56
vale, pues ya está 00:11:04
he puesto un toString 00:11:08
para ahora en el método este 00:11:11
en el que me limito a mostrar las 00:11:13
vale, pues como todavía no he hecho este método 00:11:14
¿para qué le voy a llamar? si no me va a hacer nada 00:11:17
Venga, vamos a ver si nos ha generado casas 00:11:19
Con diferentes caracteres 00:11:21
Y así 00:11:23
¿Qué hago yo? 00:11:23
Venga 00:11:29
Ay, vale 00:11:30
Sí, me la ha generado con números 00:11:36
Porque como no lo he guardado en un achar antes 00:11:38
Pero bueno, le hago el casting achar y ya está 00:11:40
Claro, porque no lo he guardado en un achar antes 00:11:42
Entonces 00:11:45
Vamos aquí 00:11:45
El achar 00:11:49
hago el casting y luego 00:11:53
este paréntesis que se cierra aquí 00:11:55
pues este 00:11:57
aquí está 00:11:59
a ver ahora 00:12:00
vale, ahora ya sí, ¿vale? 00:12:04
tengo casitas con diferentes letras 00:12:09
entonces ahora ya sí tiene sentido que se ordenen alfabéticamente 00:12:10
¿verdad? 00:12:13
es la primera vez que me he puesto 00:12:16
he dicho que había muchas posibilidades de que hubiera dos repetidas 00:12:18
hay dos casas 00:12:20
bueno, no pasa nada 00:12:21
la aleatoriedad es así 00:12:24
vale, pues entonces 00:12:27
venga 00:12:30
entonces no olvidéis nada de lo que se supone 00:12:30
que sabemos, pues generar números aleatorios 00:12:34
de pensar en general, no los quiero entre 0 y 25 00:12:36
sino entre 65 00:12:39
y lo siguiente 00:12:40
pues le sumo 65 para que el intervalo se mueva 00:12:42
como esto es un entero 00:12:44
al concatenar 00:12:46
me va a coger su valor entero 00:12:48
si yo quiero echar, pues tengo que hacer el casting 00:12:49
todas esas cosas que se supone que ya 00:12:51
tenemos interiorizadas 00:12:54
si trabajamos con soltura, ¿vale? 00:12:56
Vale, pues ya tenemos aquí 00:12:59
práctica. 00:13:01
Vale, pues ahora 00:13:06
nos han pedido 00:13:07
nos han pedido como funcionalidad 00:13:09
mostrar estas casas ordenadas 00:13:11
alfabéticamente por su dirección. 00:13:13
Bueno, pues ordenar un array 00:13:16
no es tan sencillo, no es algo que uno piense 00:13:17
y diga, ah, sí, 00:13:20
como lo del máximo, que el máximo rápidamente 00:13:22
lo dedujimos, pues vas uno por uno, 00:13:24
vas comparando si es mayor que el máximo 00:13:25
y si lo desactualizas el máximo 00:13:27
o como la media, la media 00:13:29
ah pues sí, yo voy sumando y luego digo el total 00:13:31
no, ordenar no es una cosa que uno 00:13:33
diga, uy ya está, se me ha ocurrido 00:13:35
con el máximo también 00:13:37
coges el primer capítulo de la letra 00:13:38
y la pones en la mayor 00:13:41
sí, pero no es fácil, tienes que hacer 00:13:42
varias pasadas, varias iteraciones 00:13:45
en un solo recorrido 00:13:47
no puedes ordenar, entonces 00:13:48
como ya tienes que, para ordenar 00:13:51
ya tienes que hacer por lo pronto 00:13:53
dos bucles, uno dentro de otro 00:13:55
pero ir haciendo los cambios 00:13:57
computacionalmente 00:13:58
podría empezar a ser complejo 00:14:00
sobre todo si tienes un array gigante 00:14:02
desde el momento en que tienes un array dentro de otro 00:14:04
y las iteraciones son muchas 00:14:06
ahí ya 00:14:09
el tiempo de ejecución 00:14:11
puede aumentar exponencialmente 00:14:12
entonces cuando tienes un código 00:14:15
con un bucle anidado dentro de otro 00:14:16
conviene ya sí que pensarlo muy bien 00:14:18
porque si aumentas 00:14:20
la cantidad de iteraciones 00:14:22
si aumentas 00:14:24
de repente el tamaño del array 00:14:28
a mil y las iteraciones suben a mil 00:14:29
el tiempo de ejecución te hace esto 00:14:31
y se te monta un cuello de botella 00:14:32
conclusión, hay mucho estudio 00:14:34
montado sobre 00:14:37
cuáles son los mejores algoritmos de ordenación 00:14:39
¿vale? los que hacen 00:14:42
que según aumentas el tamaño del array 00:14:43
el tiempo de aumento de ejecución 00:14:45
en lugar de ir así, pues vaya así 00:14:48
¿vale? el crecimiento puede ser 00:14:49
logarítmico o puede ser lineal 00:14:52
o puede ser exponencial, entonces hay muchos algoritmos de ordenación 00:14:53
nosotros no hemos puesto ninguno este año 00:14:57
pues porque no tenemos tiempo y porque 00:15:01
no queremos volverlo más locos 00:15:04
vale, pero resulta que ¿qué ocurre? 00:15:08
silencio, a ver callado 00:15:14
Rodrigo, tú también que me distraigo yéndote 00:15:17
vale, afortunadamente 00:15:20
no nos hace falta aprendernos 00:15:22
un algoritmo de ordenación 00:15:25
para ponerlo aquí 00:15:27
que es un ejercicio matemático estupendo 00:15:28
está el de la burbuja, el quicksort 00:15:30
uno puede ver cómo funcionan, aplicarlos y son maravillosos 00:15:32
pero no nos hace falta 00:15:35
porque resulta que tenemos una clase 00:15:36
a raíz 00:15:39
que esta clase a raíz 00:15:39
nos da un montón de métodos estáticos 00:15:43
para hacer cosas chulas 00:15:45
entonces a raíz es una clase 00:15:46
que existe aquí en la máquina virtual. 00:15:49
¿Vale? 00:15:52
En mi máquina virtual JRE 00:15:53
pues hay millones 00:15:55
de cientos de miles de clases 00:15:57
y una de las que hay 00:15:59
es la clase Arraiz 00:16:01
que está por algún lado. 00:16:03
Sí, Arraiz no está en Java lang. 00:16:07
Arraiz estará en Java útil. 00:16:09
Arraiz debe estar 00:16:12
en Java útil que estará 00:16:13
por aquí abajo. 00:16:15
Arraiz, ¿vale? 00:16:20
pues una de las miles de clases que tiene la máquina virtual 00:16:21
es la clase Arrays 00:16:23
y es una clase que tiene métodos estáticos 00:16:24
y los métodos estáticos ya sabéis que se pueden llamar 00:16:27
con el nombre de la clase 00:16:29
pues tiene muchos muy chulos 00:16:30
resulta que si uno indaga 00:16:33
tiene uno que es el sort 00:16:35
que le pasas un Array y te lo ordena 00:16:37
pues dijimos, magnífico 00:16:40
pues ya lo tengo 00:16:42
le voy a pasar 00:16:43
pero si no os pedí ordenar nada 00:16:45
era invertir 00:16:49
no ordenar 00:16:52
no me líes 00:16:53
vale, pues entonces 00:16:55
decimos, oye 00:16:58
si hay una clase Arrays que te hace cosas con Arrays 00:17:00
pues voy a aprovecharme 00:17:02
y sobre todo si me ordena 00:17:04
pues ni planto método de la burbuja 00:17:05
ni Quicksort, ni nada, y ya está 00:17:08
ah, claro, el por dentro sí 00:17:10
lógicamente, no nos da igual como lo haga 00:17:14
de hecho, seguramente 00:17:16
en la documentación te dice 00:17:18
qué método de ordenación usa. 00:17:20
A ver. 00:17:22
Ay. 00:17:27
Ah, espérate, no. 00:17:30
Me había ido al SOR directamente y me he ido. 00:17:31
En la ayuda de SOR 00:17:35
seguramente te diga qué método usa. 00:17:36
Creo que es el QuickSOR, pero no estoy segura. 00:17:48
Pero bueno, aquí te explicará. 00:17:53
estoy usando el método de ordenación patatín 00:17:54
que tiene una complejidad de no sé 00:17:56
cuántos y te explica 00:17:58
todo lo que hace, etc. 00:18:00
Anoto lo que nos importa es que ordena. 00:18:02
Y ya está. Vale. 00:18:05
Pues genial. Pues ya está. Ya tengo el código 00:18:06
hecho. Le paso esto 00:18:08
y me lo ordena. Y me lo ordena 00:18:10
y me lo deja la misma referencia, lógicamente. 00:18:12
O sea, él hace todo lo que tenga que hacer 00:18:14
y esta misma referencia 00:18:16
se queda con el 00:18:18
array ordenado. Igual que cuando nosotros 00:18:20
insertamos 00:18:22
cuando nosotros insertamos un elemento de un array 00:18:23
hacemos primero un auxiliar 00:18:26
y luego ya sobrescribimos 00:18:27
el nuevo en el 00:18:29
yo le paso un array 00:18:32
y sort coge ese array 00:18:42
con todo su tamaño, lo ordena 00:18:43
y la versión ordenada 00:18:46
la utiliza para sobrescribir 00:18:48
ese propio array 00:18:50
En casas tiene muchas cosas dentro. 00:18:50
O sea, lo ordena en base a qué. 00:18:53
Ah, muy buena pregunta. 00:18:55
Se nota que sois muy listos. 00:18:57
Vale, vale. 00:18:59
Vale, muy bien. 00:19:01
Claro. 00:19:03
Claro, es que yo no quería 00:19:05
que me hicierais esa pregunta. Yo primero 00:19:06
lo que quería era lanzar esto, a ver qué me dice. 00:19:08
¿Vale? Entonces, si me lo ordena, 00:19:10
pues a punto pelota. 00:19:13
Vamos a ver. Vamos a ver qué es lo que hace. 00:19:17
de hecho vamos a probarlo primero 00:19:19
en uno que me ordene numeritos 00:19:21
a ver 00:19:24
int 00:19:25
números 00:19:27
y le vamos a poner 00:19:30
3 menos 6 00:19:31
si que ya lo se 00:19:36
que 00:19:43
es que 00:19:44
de verdad 00:19:47
Ah, sois ahí. 00:19:48
No, no se estoy mareando. 00:19:53
Vamos a ver cómo funciona. 00:19:58
No cobro por alumnos, por número de alumnos. 00:20:07
Yo voy a cobrar igual, yo soy funcionaria. 00:20:13
Vale, pues entonces vamos a ordenarlo 00:20:15
Arrays, que no, que nos quiero liar 00:20:19
Números 00:20:25
Vale, yo le paso mi array de números 00:20:27
Y ahora vamos a 00:20:33
¿Cómo se llama el método? 00:20:35
Ordena números 00:20:38
Le paso mi array de números 00:20:39
Y vamos a ver esos números 00:20:46
como me los ha puesto, para cada numerito 00:20:48
en el nuevo array 00:20:50
números, vamos a mostrar 00:20:52
vamos a verificar que funciona el método 00:20:54
no vaya a ser que estemos tirando con un 00:20:56
vale, vamos a ver 00:20:58
yo le he metido esto, me tendrá que mostrar 00:21:00
menos 6, 3, 4 y 8 00:21:02
menos 6, 3, 4 y 8 00:21:03
vale, funciona 00:21:08
venga, pues efectivamente 00:21:10
ahora, aunque 00:21:12
nos huele raro, ya lo sabemos 00:21:14
que nos huele raro 00:21:16
vamos a ver que hace 00:21:17
Vamos a ver qué hace. 00:21:19
Vale. 00:21:24
Asumís que ordena por dirección de memoria. 00:21:25
Venga, vamos. 00:21:29
No lo sé. 00:21:33
No lo sé. 00:21:35
Vamos a ver qué hace. 00:21:35
Esta parte ya la comentamos. 00:21:36
Ya hemos verificado que ordena mis números, 00:21:37
que ArraySource funciona. 00:21:39
Vamos a ordenar las casas ahora. 00:21:41
Y ahora ya vamos a mostrarlas. 00:21:43
para cada casa 00:21:45
C en las casitas estas que tengo 00:21:47
muéstramela 00:21:50
y voy a poner aquí un este 00:21:53
para que se vea claro que 00:21:56
a partir de ahí son ordenadas 00:21:57
venga 00:22:03
pues no me hace nada, se niega 00:22:04
¿vale? 00:22:08
¿y qué me dice? 00:22:10
me dice, lo siento, pero casa 00:22:12
no es 00:22:14
comparable 00:22:17
efectivamente, en idioma de Java es 00:22:18
no puedo comparar las casas 00:22:21
entre sí 00:22:23
entonces, si no puedo comparar qué casa 00:22:24
es mayor que otra, a diferencia de los 00:22:27
números, que si puedo comparar 00:22:29
no puedo, vale 00:22:30
pues efectivamente 00:22:33
¿qué significa ser comparable? 00:22:34
que algo sea comparable 00:22:38
que se comporte 00:22:39
de manera que pueda ser comparado 00:22:41
entonces Java necesita 00:22:43
que una casa se comporte de manera 00:22:45
que pueda ser comparado 00:22:47
¿cómo se programa 00:22:48
y se diseña todo eso en Java? 00:22:51
pues con las herramientas que conocemos 00:22:53
que no hay más, entonces Java dice 00:22:55
vale, como yo necesito que las cosas 00:22:57
puedan ser comparadas 00:22:59
como necesito que las cosas 00:23:01
tengan el comportamiento de ser comparadas 00:23:03
pues voy a hacerme 00:23:05
una interfaz con ese comportamiento 00:23:07
y el que quiera ser comparado 00:23:09
que lo implemente. ¿Cómo se llama 00:23:11
esa interfaz? Pues como no podía darse otra 00:23:13
manera, incomparable. Entonces, 00:23:15
ahora ya decimos, claro, 00:23:17
yo necesito que casa 00:23:19
sea comparado. La necesito 00:23:21
no siempre por definición. 00:23:23
Lo necesito desde el momento en que 00:23:26
se la voy a pasar a un sort. 00:23:27
Porque sort es el que tiene que comparar. 00:23:29
Entonces, cuando aquí yo mostraba 00:23:31
las casas o todo, aquí que fueran 00:23:33
comparables o no, daba igual 00:23:35
porque aquí nadie necesita compararlas. 00:23:37
Pero aquí el método 00:23:40
sort dice, muy bien, 00:23:41
tengo varias casas. Necesito 00:23:43
que podáis ser comparables 00:23:45
entre vosotras. Y eso significa que 00:23:47
tengáis ese comportamiento dentro 00:23:49
de vosotras. 00:23:51
Pues entonces, para tener un comportamiento, adherirse 00:23:53
al comportamiento, Java se traduce a 00:23:55
tienes que implementar la interfaz correspondiente 00:23:57
a ese comportamiento. Pues la 00:23:59
interfaz correspondiente al comportamiento 00:24:01
de ser comparable entre sí es la 00:24:03
comparable. Dicimos, ah, vale, 00:24:05
pues no pasa nada, no te preocupes. 00:24:07
Voy a hacer que mis 00:24:10
casas implementen 00:24:11
esa interfaz 00:24:13
comparable. 00:24:14
No. 00:24:18
No. Estoy poniendo como ejemplo 00:24:21
de que el diseño de la máquina 00:24:23
virtual y de todo ya está hecho así. Esa interfaz ya existe. 00:24:25
Esa interfaz ya existe 00:24:28
y tiene dentro el método 00:24:29
al que hay que llamar cuando yo 00:24:31
quiero que un objeto se compare con otro. 00:24:33
Esa interfaz ya existe. Entonces, todo está 00:24:35
ya hecho con esta arquitectura. 00:24:37
Y tú tienes que entenderla 00:24:39
para cuando necesites 00:24:40
integrarte en el mundo 00:24:42
mi entidad 00:24:44
casa que yo me acabo de inventar 00:24:46
se va a integrar 00:24:48
en este universo 00:24:50
de clases de Java y se va a integrar 00:24:52
porque yo quiero que sea ordenada 00:24:54
a través de sort del método Arrays 00:24:56
entonces mi entidad casa se va a integrar 00:24:58
entonces si se va a integrar en este mundo 00:25:00
en este universo en el que las cosas 00:25:02
pueden ser comparadas, intégrate 00:25:04
pero entonces implementa esa interfaz que es la que yo tengo 00:25:06
hecha aquí para que las cosas 00:25:08
sean comparadas, entonces todo lo que ya está 00:25:10
hecho, porque nosotros usamos clases que están hechas 00:25:12
continuamente, ahora las de 00:25:14
la máquina virtual, pero en el futuro 00:25:16
las que descarguemos de por ahí, pues 00:25:18
todo está hecho con una arquitectura de cosas 00:25:20
y tú tienes que jugar 00:25:22
con esas reglas del juego 00:25:24
bueno, pues si yo quiero jugar con sort 00:25:25
sort me dice 00:25:28
vale, pues implementame comparable 00:25:29
venga, pues yo 00:25:32
te implemento comparable 00:25:34
¿qué pasa cuando implementamos una interfaz? 00:25:35
que estamos obligados 00:25:38
a implementar todos los métodos 00:25:40
que tenga. Entonces, claro, yo no me puedo 00:25:42
saber de memoria cómo son los métodos. 00:25:44
O bien me voy a documentación de 00:25:46
comparable, la abro para ver 00:25:48
cuáles son sus métodos, me abro aquí, 00:25:50
comparable, venga, tú eres esta interfaz, 00:25:52
va a tardar un huevo en abrirla, 00:25:55
paso. 00:25:56
Lo tiene que construir toda la... 00:25:58
No, no, paso, paso. O bien la 00:26:00
abro y me meto en la documentación a ver cómo se 00:26:02
llaman los métodos vacíos, 00:26:04
o si tengo un entorno de desarrollo que es más fácil, 00:26:06
pincho aquí y él me dice 00:26:08
oye, añade los métodos 00:26:10
que están sin implementar, doble clic 00:26:12
y me va a añadir 00:26:14
todos los métodos, pero vacíos 00:26:16
tú aquí haces lo que te dé la gana 00:26:18
me ha añadido sólo uno 00:26:20
porque comparable sólo tiene un método 00:26:22
que es el compare tú 00:26:23
vale, pues este 00:26:25
método 00:26:28
hay que entender cómo se usa 00:26:28
bueno, pues este método 00:26:31
compare tú, lo va a llamar un objeto casa 00:26:34
que va a recibir 00:26:36
otro objeto. Entonces, 00:26:38
para tú jugar con las mismas reglas 00:26:40
que juega la interfaz 00:26:42
comparable y el mundo Java que está en la 00:26:43
máquina virtual, para tú jugar con las mismas reglas 00:26:46
tienes que conocerlas. 00:26:47
Y las reglas son, 00:26:49
uno se va a la documentación y lo ve, pero las reglas 00:26:51
son, os ahorro ese paso, 00:26:53
que, eso tiene que volver un entero, 00:26:56
eso está claro, tiene que volver un entero. 00:26:58
Si lo que devuelves es negativo, 00:27:00
se asume 00:27:03
que el objeto que llama al método 00:27:04
va antes 00:27:06
que el pasado como parámetro 00:27:07
si lo que devuelve es cero 00:27:09
se asume que el objeto 00:27:13
que llama al método 00:27:15
y el pasado como parámetro 00:27:16
es que están en la misma posición 00:27:18
¿vale? no hay uno antes que otro 00:27:20
en el caso de números sería el mismo 00:27:22
tres y tres 00:27:24
en el caso de cadenas es la misma cadena 00:27:25
no va uno antes que la otra 00:27:28
y si lo que devuelve es positivo 00:27:29
se asume 00:27:32
que el objeto que llamó al compare tú 00:27:33
está después en orden 00:27:36
que el que yo le paso. 00:27:39
Vale, pues esas son las reglas. 00:27:42
Yo tengo que jugar con esas reglas. 00:27:43
Pues ahora ya me invento aquí 00:27:45
el código para conseguir 00:27:47
que cuando dé un negativo 00:27:49
la casa que llama al método 00:27:51
va antes que la pasada como parámetro, 00:27:53
cuando dé cero 00:27:56
son la misma casa, y cuando 00:27:57
dé positivo, la casa 00:27:59
que llama al método va después. 00:28:01
Entonces yo ahora ya hago el código 00:28:03
pensando, vale, ¿cuál es mi criterio 00:28:04
de orden? Mi criterio de orden va a ser 00:28:07
la dirección, entonces tengo que mirar 00:28:08
si la propiedad 00:28:11
dirección de dis 00:28:13
entonces aquí lo que tengo que hacer 00:28:14
es, en realidad 00:28:16
si yo lo 00:28:18
si la 00:28:21
propiedad dirección 00:28:24
de dis 00:28:26
del objeto dis que llama al método 00:28:28
está antes 00:28:30
alfabéticamente, porque es un string 00:28:34
luego el orden es alfabético, alfabéticamente 00:28:35
bueno, pero los números son 00:28:38
caracteres también, el orden es alfabético 00:28:43
según la tabla ASCII, antes que 00:28:46
la propiedad 00:28:48
dirección 00:28:50
de quién 00:28:52
de O 00:28:54
de este que me han pasado 00:28:55
pues en ese caso tengo que devolver 00:28:57
un negativo 00:29:02
esto mismo 00:29:02
sin embargo 00:29:15
si la propiedad dirección de dis 00:29:16
del objeto que llama el método 00:29:18
la propiedad dirección 00:29:20
está después 00:29:21
me las tengo que apañar para devolver un positivo 00:29:23
no, cero es si es el mismo 00:29:28
exactamente 00:29:32
si ambas direcciones 00:29:33
son la misma 00:29:37
devuelvo cero 00:29:42
entonces tengo que hacer un código 00:29:47
que refleje esta idea, que es la que yo quiero 00:29:49
si la propiedad dis 00:29:51
de la casa que llama al método 00:29:53
va antes que la propiedad dis de este 00:29:55
devuelvo negativo 00:29:57
si va después devuelvo positivo 00:29:58
y si no devuelvo cero, eso es lo que tengo yo que programar 00:30:01
y cuando este esté ya programado 00:30:03
ya el sort 00:30:06
sabrá como ordenarlo 00:30:07
vale, entonces esto 00:30:09
no es tan 00:30:11
no es tan difícil de programar 00:30:12
tampoco es tan fácil, vamos a 00:30:15
pensar 00:30:17
¿Vale? 00:30:19
Vale. 00:30:21
A ver, lo que tenemos... 00:30:23
Venga, dos minutillos. 00:30:25
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
29 de enero de 2025 - 12:57
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 29″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
136.65 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid