Saltar navegación

240219 Interfaces1 - 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 19 de febrero de 2024 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, por lo tanto si habláis me dais el permiso de grabar vuestra voz 00:00:00
Entonces, nosotros hemos hablado de clases de herencia 00:00:06
Clases padres, clases hijas, etc. 00:00:14
Hemos visto la clase abstracta y hemos visto un poco que es el polimorfismo 00:00:17
En vídeos anteriores 00:00:21
Entonces, el último concepto interesante que hemos visto 00:00:23
Era esta de aquí, del... bueno, que no es interesante. Era eso de las clases abstractas y los métodos abstractos, ¿vale? Entonces, yo utilizo un método abstracto cuando a este nivel, cuando estoy modelizando esta clase, no sé todavía cómo se implementa este método, pero entiendo que este método es útil para esta clase. 00:00:28
Yo estoy creando 00:00:49
El ejemplo es la clase coche 00:00:51
Y es útil que cada coche 00:00:53
Perdón, la clase vehículo 00:00:55
Y es útil que cada vehículo se mueva 00:00:56
Por lo tanto, puedo decir 00:00:58
Oye, mira, cada vehículo tiene que tener 00:01:00
Su método de moverse 00:01:01
¿Vale? 00:01:05
Luego, cómo se implementa de verdad 00:01:06
Depende de si es un coche o un avión 00:01:08
El coche dirá 00:01:10
Voy andando 00:01:11
Voy cocheando 00:01:13
Y el avión dirá 00:01:15
Voy volando 00:01:18
¿Vale? 00:01:18
Pero me da igual 00:01:19
Lo mismo, figura geométrica 00:01:19
Pues si yo tengo una figura geométrica 00:01:22
Tiene sentido que todas las figuras geométricas tengan un área 00:01:24
¿Vale? Se puede calcular área 00:01:27
Método calcular área 00:01:28
Pero ¿Cómo se calcula el área de una figura geométrica? 00:01:29
No lo sé 00:01:32
Hasta que no sé cuál es la figura geométrica 00:01:33
Por lo tanto, tengo los métodos abstractos 00:01:35
Los métodos abstractos me crean una clase abstracta 00:01:38
Os recuerdo que las clases abstractas no se pueden instanciar 00:01:42
Si yo tengo la clase abstracta figura geométrica 00:01:46
No puedo hacer ni un figura geométrica 00:01:49
¿Vale? No se puede crear una instancia de una clase abstracta 00:01:52
¿Por qué? Porque es abstracta, no es concreto 00:01:55
Porque le faltaría parte del código 00:01:57
Porque hay algunos métodos que no están implementados 00:02:00
¿Sí? 00:02:04
Vale, hay una situación extrema 00:02:07
En el que podríamos decir 00:02:10
vale, mas si yo en vez de hacer una clase 00:02:14
que como figura geométrica 00:02:16
que tenía algunas cosas que si podía 00:02:17
implementar y otras no 00:02:20
pues tengo una idea 00:02:21
un concepto, un algo 00:02:23
que estoy modelizando y nada 00:02:25
de eso lo puedo instanciar 00:02:28
lo puedo implementar 00:02:30
vale, es decir 00:02:32
tengo varios métodos que serían 00:02:33
útiles para este concepto que estoy 00:02:36
modelizando, pero todos son 00:02:37
métodos abstractos 00:02:40
vale, si una clase 00:02:41
Tiene métodos solo abstractos 00:02:43
Lo más probable 00:02:47
Hay excepciones 00:02:49
Pero es que en realidad no sea una clase 00:02:50
Sea una interfaz 00:02:53
¿Vale? 00:02:54
La interfaz es un concepto parecido a la clase abstracta 00:02:56
Solo que os recuerdo que la clase abstracta no es solo abstracta 00:03:00
La clase abstracta puede tener métodos que yo implemento y los escribo directamente 00:03:03
Y luego hay 1, 2, 3, 7 métodos 00:03:06
Que digo, vale, estos de aquí los dejo a mis hijos 00:03:09
Lo implementarán mis hijos. Te digo aquí que existen estos métodos, pero luego serán mis hijos los que lo implementarán. Oye, ¿por qué esto? ¿Qué cosa interesante tiene esto de decir, a nivel de superclase, existe moverse y luego dejar que sean los hijos que lo implementen? 00:03:13
Por polimorfismo 00:03:34
Porque si yo me creo la figura geométrica 00:03:41
Y le digo, oye mira, calcula área, tiene que estar 00:03:45
¿Vale? 00:03:48
Y luego mis hijos lo implementarán 00:03:49
Lo que puedo hacer ahora es crearme un array de figuras geométricas 00:03:52
Y llamar directamente sobre estos objetos figura geométrica 00:03:58
Calcularia 00:04:02
Porque no se usará el calcularia 00:04:04
De figura geométrica 00:04:07
Mas se usará el calcularia de mi subclase 00:04:08
Por polimorfismo 00:04:11
Vale 00:04:15
Entonces volviendo a las interfaces 00:04:17
Cuando 00:04:21
Todos los métodos que yo estoy 00:04:22
Definiendo son abstractos 00:04:25
Muy probablemente estoy hablando 00:04:28
De una interfaz 00:04:30
Una interfaz 00:04:31
Es un molde, es un contrato, es una forma de decirme, de meter por escrito en cierto sentido 00:04:32
Una estructura, un conjunto de métodos que mi clase seguramente tendrá que tener 00:04:44
Es decir, yo tendré una clase y esta clase puede, como antes se extendía a otra clase 00:04:54
Puede implementar una interfaz 00:05:01
Si mi clase, mi clase vehículo 00:05:05
Implementa la interfaz poder moverse 00:05:09
Quiere decir que dentro del vehículo 00:05:14
Tiene que estar implementados todos los métodos 00:05:17
Que la interfaz puede moverse me define 00:05:22
Entonces en la interfaz poder moverse 00:05:27
Yo tendré el método moverse 00:05:29
tendré el método moverse rápido, tendré el método parar, tendré el método repostar, qué sé yo. 00:05:31
Todos estos, ¿vale? Son como un contrato que tú me firmas diciendo, mira, en el momento que implementas mi interfaz, 00:05:38
te comprometes a cumplir que todos estos métodos serán implementados. 00:05:46
Entonces cuando coche 00:05:51
Extende vehículo 00:05:52
Implementa 00:05:54
Poder moverse 00:05:55
Pues yo sé que en coche tendrá que aparecer 00:05:58
Moverse, moverse rápido 00:06:00
Repostar y pararse 00:06:02
¿Para qué me sirve en la vida real? 00:06:03
Pues por muchas cosas 00:06:09
¿Vale? 00:06:10
Primero porque puedo dividir trabajo 00:06:12
Entre grupos de trabajo 00:06:14
¿Vale? Yo te doy una interfaz 00:06:15
Diciendo mira 00:06:18
Tus objetos tienen que cumplir 00:06:18
Con esta interfaz 00:06:21
Luego tú lo trabajas 00:06:22
Pero desde fuera otro equipo 00:06:25
Ya puede saber cuáles son los métodos 00:06:27
Que puede utilizar solo tus objetos 00:06:30
Porque si tú cumples la interfaz 00:06:31
Esos métodos tendrán que estar 00:06:34
Yo puedo decir a vosotros 00:06:35
Implementad este vehículo 00:06:37
Que puede moverse 00:06:39
Y por otro lado 00:06:40
Tengo un programa gestional 00:06:43
Que usa vehículos 00:06:45
Y que pueda utilizar tranquilamente los métodos 00:06:47
Moverse, moverse rápido o repostar 00:06:50
Porque no sabe cómo están hechos 00:06:52
Pero saben que vosotros lo vais a implementar 00:06:54
Porque tiene la interfaz 00:06:58
¿Se entiende? 00:06:59
Es como un punto de unión entre otros 00:07:00
¿Cómo pasaba con las clases abstractas? 00:07:03
Yo puedo crear objetos de tipo interfaz 00:07:08
¿Vale? 00:07:12
Si mi interfaz es poder moverse 00:07:13
Pues yo puedo crear un objeto poder moverse 00:07:15
Poder moverse x es igual 00:07:19
Pero luego como instancia 00:07:21
No puedo poner ni un poder moverse 00:07:24
Porque poder moverse es completamente abstracto 00:07:26
Es una interfaz 00:07:29
No puedo crear una interfaz 00:07:30
Una instancia de una interfaz 00:07:32
Lo que si puedo crear 00:07:35
Es cualquier objeto que implemente esa interfaz 00:07:36
Entonces si yo puedo hacer 00:07:41
Poder moverse, que se llama X, es igual a new coche 00:07:45
Si el coche implementa poder moverse 00:07:50
Vale, tened en cuenta que 00:07:54
Mientras yo estoy forzado a extender como mucho una sola clase 00:08:00
Siempre cuando hago extends de herencia en Java 00:08:05
Se puede extender una sola clase 00:08:10
En realidad yo puedo implementar cuantas interfaces me da la gana 00:08:13
Interfaces puedo implementar 7, si quiero 00:08:17
Y es la forma que usa Java para implementar un mecanismo parecido a lo que es la herencia múltiple 00:08:21
¿Vale? En otros lenguajes, como en C++, tú puedes heredar de varias clases 00:08:28
En Java heredas de una clase sola, pero puedes implementar muchas otras interfaces 00:08:33
Se parece a la clase abstracta 00:08:40
Pero con la diferencia que 00:08:43
Estas 00:08:44
Todas sus métodos son 00:08:45
Obviamente abstractos 00:08:48
Como todos los métodos son abstractos 00:08:50
Dentro de una interfaz 00:08:53
No hace falta poner el abstract 00:08:55
El abstract 00:08:57
La palabra abstract 00:08:58
En una clase 00:08:59
Tú puedes tener métodos normales y métodos abstractos 00:09:01
Entonces tiene que marcar cuáles son normales 00:09:04
Y cuáles son abstractos 00:09:06
En una interfaz no puedes tener métodos que se implementan 00:09:07
Son todos abstractos 00:09:12
Entonces no hace falta marcar cuáles son de un tipo o cuáles son de otro 00:09:13
En Java se usa interface 00:09:16
Cuando tú dices public, class, no sé qué y la implementas 00:09:25
Si quieres hacer una interfaz en vez de una clase 00:09:29
Pues haces public interface y el nombre de la interface 00:09:32
Para crear una clase 00:09:36
Que escriba código para los métodos 00:09:40
De una interfaz, se obtendrá la palabra 00:09:42
Implements, en vez que extends 00:09:43
O sea, mi clase 00:09:45
Extend, clase padre 00:09:47
Implements 00:09:49
La interfaz que quiero 00:09:51
Puedo no extender 00:09:53
O sea, public class 00:09:57
Mi clase 00:09:59
Implements 00:10:01
Con verbo 00:10:03
Se pueden declarar referencias a objetos cuyo tipo sea una interfaz 00:10:04
¿Vale? En lugar que una clase 00:10:15
O sea, si yo tengo la interfaz comparable 00:10:17
Pues lo que puedo hacer es hacer comparable nombre de la variable 00:10:20
Es igual, pero la instancia no puede ser esta interfaz 00:10:25
No puede hacer comparable x es igual a new comparable 00:10:30
No existe 00:10:34
No puedo crear una instancia de una interfaz 00:10:35
Lo que sí puedo hacer es 00:10:38
Comparable x es igual a new cocodrilo 00:10:40
Siempre y cuando cocodrilo implemente esta interfaz 00:10:45
¿Sí? 00:10:52
¿Me seguís? 00:10:54
Ahora luego hacemos ejemplos 00:10:55
Su principal función es establecer y estabilizar las interfaces 00:10:57
De una clase para que 00:11:02
Sus deseadores puedan coordinarse 00:11:04
La interfaz se llama así 00:11:06
Porque al fin y al cabo 00:11:09
¿Qué es una interfaz? 00:11:10
Es la forma con que 00:11:13
Por ejemplo 00:11:15
Un usuario 00:11:16
Se conecta 00:11:18
Puede interactuar 00:11:21
Con un programa 00:11:22
La interfaz de usuario 00:11:23
Por ejemplo 00:11:25
En Windows 00:11:26
Cuando vosotros encendéis el Windows 00:11:29
Eso no es el Windows 00:11:32
Lo que veis vosotros no es el Windows 00:11:34
Windows es otra cosa 00:11:36
Es un conjunto de programas 00:11:38
Que es el kernel que se ha cargado en memoria 00:11:39
Está allí 00:11:41
Que nadie puede trabajar con él 00:11:41
¿Vale? 00:11:43
A vosotros se os enseñan 00:11:45
Ventanitas bonitas 00:11:47
Con botones grandes así 00:11:48
Y vosotros clicáis sobre los botones 00:11:50
¿Sí? 00:11:52
Pues esa es una interfaz 00:11:53
La interfaz entre el sistema operativo 00:11:55
Que está por debajo 00:11:57
Que es el que gestiona el acceso a la red 00:11:58
Gestiona el acceso a los ficheros 00:12:00
Carga los programas, crea los procesos 00:12:02
Etcétera, etcétera 00:12:05
Tiene una interfaz bonita 00:12:06
De ventanitas y botones 00:12:08
Que vosotros utilizáis 00:12:10
Pues esto es un poquito lo mismo 00:12:11
Yo creo un punto de acceso a mi sistema 00:12:13
Y digo a los demás, oye mirad 00:12:16
Vosotros aquí podéis utilizar estos métodos 00:12:18
Cualquiera que acceda a esta interfaz 00:12:21
Estos son los métodos que yo proporciono 00:12:23
Es un menú, es un contrato 00:12:25
Esto es lo que puede hacer 00:12:27
Ahora úsame como te da la gana 00:12:29
Pero estos son los métodos que me puede llamar 00:12:31
¿Y cómo están implementados? 00:12:33
No te interesa 00:12:34
Yo los he implementado como se tenían que implementar 00:12:36
Pero estas son las cosas que tienen que funcionar 00:12:40
El objeto, el método moverse de la clase puede moverse 00:12:43
¿Cómo está implementado? 00:12:49
Pues no lo sé, depende de la clase que lo implemente 00:12:50
La clase coche implementará este método de una forma 00:12:53
La clase avión de otra forma 00:12:56
A la clase, se traen de otra forma 00:12:58
Pero yo sé que como estas tres clases 00:13:00
Implementan 00:13:03
La interfaz puede moverse 00:13:04
Pues los tres tienen que tener 00:13:06
El método de moverse 00:13:08
¿Se entiende? 00:13:09
Vamos a ver 00:13:20
Esto es más o menos lo que he dicho ahora 00:13:21
Tened en cuenta que 00:13:26
Imaginaos que yo tenga dos grupos de trabajo 00:13:28
Este grupo es el que está encargado 00:13:31
De implementar 00:13:34
Estos métodos, vale, entonces le paso la interfaz 00:13:35
Le digo, mira, la interfaz 00:13:37
Puede moverse, moverse rápidamente 00:13:39
No sé qué, vale, implementalos tú 00:13:41
Y luego le digo a otro grupo 00:13:43
Mira, tú tendrás en el futuro 00:13:45
Este 00:13:47
Objeto implementado que puede hacer 00:13:49
Estas cosas, pero ahora no 00:13:51
Porque estamos trabajando en paralelo 00:13:53
Entonces, claro, el sistema que va a usar 00:13:54
Este objeto 00:13:58
Sabe por contrato 00:14:01
Cuáles son los métodos 00:14:03
Pero claro, si intenta utilizarlos 00:14:04
Todavía no tiene la clase 00:14:06
Y por lo tanto no funcionaría 00:14:07
Existe una técnica avanzada 00:14:09
Que son los objetos mock 00:14:12
¿Vale? 00:14:14
Son objetos falsos 00:14:15
Son objetos que 00:14:17
En vez de hacer 00:14:19
Que el coche se mueva de verdad 00:14:22
Como lo implementará en el grupo 00:14:24
De trabajo que implementa los coches 00:14:25
Lo que hace es que te escribe simplemente 00:14:27
Si has conseguido mover el coche 00:14:30
Una forma falsa de implementar esta interfaz 00:14:31
Que sirve para que los dos programadores 00:14:39
O sea, los dos grupos de programadores puedan trabajar a la vez 00:14:42
Está claro que el sistema no funcionará 00:14:45
Lo que recibirá son solo informaciones falsas 00:14:47
Informaciones mock, ¿vale? 00:14:51
Pero puede funcionar 00:14:53
Volvemos sobre esto cuando entendemos un poquito más de interfaces 00:14:56
¿Vale? 00:14:59
Ejemplo 00:15:01
Entonces, imaginaos que yo creo 00:15:02
La interfaz animal 00:15:06
¿Vale? 00:15:09
La interfaz animal 00:15:11
Tiene el método habla 00:15:12
¿Vale? 00:15:17
Este método, ¿cómo es? 00:15:19
Tiene una implementación 00:15:22
¿Puede tener una implementación? 00:15:24
¿Aquí? 00:15:32
Porque estoy en una interfaz 00:15:34
Eh, pero deberías poner abstract 00:15:36
No, porque en una interfaz 00:15:38
Todos los métodos que declaro son abstractos 00:15:41
¿Me acuerdo con esto? 00:15:43
Entonces, si yo he creado 00:15:46
Una interfaz, que es un contrato 00:15:47
Si tú quieres cumplir 00:15:49
Con el contrato que te he dado yo 00:15:51
O sea, si tu clase implementa animal 00:15:53
Entonces, por algún lado de tu clase 00:15:57
Tendrás que poner una implementación de habla 00:16:00
¿Está claro hasta aquí? 00:16:03
¿Tú das? 00:16:07
Entonces, por ejemplo, puedo crear la clase perro 00:16:09
Que implementa animal 00:16:12
Entonces, ¿qué quiere decir? 00:16:15
Que la clase perro puede tener lo que le da la gana 00:16:17
Pero por algún lado tendrá que tener un public void habla 00:16:19
Que es lo que ponía antes 00:16:23
¿Vale? 00:16:24
E implementar que el perro hace guau 00:16:25
¿Si? 00:16:28
Y puede implementar 00:16:32
La clase gato 00:16:34
Que implementa la interfaz animal 00:16:36
Esto quiere decir que 00:16:39
Gato será colusea 00:16:40
Pero por algún lado tendrá que tener el método habla 00:16:42
Y implementarlo 00:16:45
¿Están de acuerdo con esto? 00:16:47
Vale 00:16:50
Entonces con estas dos clases 00:16:50
Fijaos que aquí es class 00:16:53
Y aquí es interface 00:16:54
Entonces tengo dos classes 00:16:56
Y una interfaz 00:16:59
¿Qué puedo hacer con eso? 00:16:59
Puedo crear 00:17:03
Un animal dog 00:17:05
Fijaos esta es la interfaz 00:17:06
Con dentro una instancia perro 00:17:08
Y un animal cat 00:17:11
Con dentro una instancia gato 00:17:13
Esto lo puedo hacer 00:17:15
Puedo hacer 00:17:16
Gato dog es igual a 00:17:18
Perro dog es igual a perro 00:17:19
a new perro, o gato 00:17:22
cat es igual a new gato 00:17:24
o puedo hacer animal dog 00:17:25
es igual a new perro 00:17:28
lo puedo hacer, lo que no 00:17:30
puedo hacer es animal 00:17:32
no sé qué, es igual a new 00:17:34
animal, new animal 00:17:36
no tiene sentido, porque 00:17:38
animal no es una clase 00:17:40
es una interfaz 00:17:41
pero esto es muy parecido a lo que hemos visto 00:17:44
con el polimorfismo 00:17:48
Y ahora tengo objetos-animal 00:17:49
Podría tener un array de animales 00:17:52
Un array de objetos-animal 00:17:54
Y dentro poner gato, perros, cocodrilos y ranas 00:17:56
¿Sí? 00:18:02
Ahora, ¿qué pasa? 00:18:04
Que todos los animales 00:18:05
Que no es una clase, repito 00:18:07
Es un intervalo 00:18:10
Tienen necesariamente que tener habla 00:18:12
Entonces, en todas las instancias animal 00:18:14
Yo puedo decirle que hable 00:18:17
Solo que por polimorfismo 00:18:20
No se usará el habla 00:18:23
De la interfaz animal 00:18:25
Que además es abstracto 00:18:28
Y no tiene una implementación 00:18:30
Mas se usará 00:18:31
El habla 00:18:32
De la clase 00:18:35
De la instancia 00:18:37
Lo que decíamos antes con el polimorfismo 00:18:38
Cuando hay 00:18:41
Un método que es sobrescrito 00:18:42
En una clase que hereda 00:18:45
En este caso, en la clase que implementa esta interfaz 00:18:47
Pues se va a utilizar el método más específico de esa clase, de esa instancia 00:18:51
No de la superclase o de la interfaz 00:18:56
Por lo tanto, cuando yo hago dog.habla 00:19:00
No voy a usar la implementación de animal 00:19:03
Y fijaos que dog es un animal 00:19:06
La referencia de dog es un animal 00:19:07
Justo 00:19:10
Pero en realidad la instancia es un perro 00:19:12
Por lo tanto, se va a utilizar habla de la clase perro. 00:19:16
O sea, que dog.habla me dirá, wow. 00:19:21
Cuando aquí cat, que de su tipo es animal, ¿vale? 00:19:25
Pero dentro tiene una instancia gato, hace habla, ¿puede llamar habla? 00:19:30
Sí, porque habla está definido dentro de la interfaz animal. 00:19:35
Y por lo tanto, sí se verá este método. 00:19:40
Pero a la hora de ejecutarlo 00:19:41
Java me va a buscar 00:19:44
El habla más específico 00:19:46
De la instancia 00:19:48
Cat 00:19:49
Y la instancia cat es un gato 00:19:50
Y por lo tanto me dirá miau 00:19:53
¿Se entiende? 00:19:55
Esto es lo mismo que hemos visto antes 00:20:00
En polimorfismo 00:20:02
Pero un poquito cambiado 00:20:04
En vez de utilizar 00:20:07
Clases abstractas estoy utilizando 00:20:08
esta versión nueva que son las interfaces 00:20:10
entonces ahora 00:20:12
yo me puedo hacer 00:20:14
un array de animales 00:20:15
poner que en animales 00:20:18
de 0 bad dog, en animales de 1 bad cat 00:20:22
porque estos son animales 00:20:24
no son gato y perro 00:20:26
y puedo llamar 00:20:27
que hablen todos 00:20:31
pasándole este array 00:20:32
¿qué es que hablen todos? pues es un 00:20:33
metodito que lo que hace 00:20:37
es recibir una rey de animales 00:20:38
y por cada animal 00:20:41
de la rey de animales 00:20:43
hace que hable 00:20:44
¿cuánto? 00:20:45
Si usas como animal 00:21:08
No, la referencia es animal 00:21:12
Te aparecerán solo los métodos 00:21:14
Definidos aquí 00:21:16
Si quería habla, come y salta 00:21:17
Pues te vendrán los métodos 00:21:20
Definidos en animal 00:21:21
Pero siempre puedes hacer un casting 00:21:22
¿Vale? 00:21:25
Tú puedes pillar este dog 00:21:26
Decirle perro de dog 00:21:28
Y como esta es una instancia de perro 00:21:31
Pues te funciona 00:21:34
Si no lo sé, si es una instancia o no 00:21:34
Siempre me queda el preguntarlo 00:21:37
Dog instants of 00:21:41
Perro, entonces 00:21:43
Castea perro 00:21:45
De dog 00:21:47
Y usa los métodos 00:21:49
Ahora hacemos ejemplos luego físicos 00:21:50
¿Vale? 00:21:53
Se entiende más o menos esto 00:21:55
No es 00:21:56
Muy nuevo 00:21:57
Si habéis entendido 00:22:00
Polimorfismo 00:22:02
Y clases abstractas 00:22:04
es más de lo mismo 00:22:06
¿vale? si no lo habéis entendido 00:22:08
lo acabamos de repasar antes 00:22:11
y lo acabamos de repasar ahora 00:22:12
grabado, entonces 00:22:14
escucháoslo con calma en casa 00:22:16
una y otra vez 00:22:18
hasta que como mínimo 00:22:20
sepáis cuál es vuestra duda 00:22:22
dónde os perdéis en este razonamiento 00:22:24
¿ok? aún así 00:22:26
haremos más ejercicios 00:22:28
y más pruebas 00:22:30
Existen 00:22:31
Interfaces 00:22:39
Bien conocidas 00:22:42
Como por ejemplo 00:22:44
Muy importante que utilizaremos 00:22:45
La interfaz comparable 00:22:47
La interfaz comparable es una interfaz 00:22:49
Que no he creado yo 00:22:52
Que está en el Java API 00:22:53
Que está en el core de Java 00:22:55
Y es sustancialmente una interfaz 00:22:57
Para decir que si tu implementas 00:22:59
Comparable 00:23:02
Estas dando a tus objetos 00:23:02
La posibilidad de ser comparado 00:23:05
Entre ellos 00:23:08
Cuando yo implemento 00:23:08
Comparable 00:23:11
Quiere decir que por algún lado 00:23:12
Tendré que implementar 00:23:14
Este método de aquí 00:23:16
¿Vale? 00:23:20
Y este método de aquí 00:23:21
Me permite 00:23:23
Comparar 00:23:25
Entre ellos dos objetos 00:23:27
De mi clase, yo creo la clase perro 00:23:29
¿Vale? 00:23:31
Digo que perro 00:23:33
Implements comparable 00:23:34
Quiere decir que por algún lado tendré que implementar 00:23:36
Int compare to 00:23:39
Objeto, ¿vale? 00:23:40
Y el resultado de este mensaje 00:23:43
Es, de este método es 00:23:45
Menos uno 00:23:47
Si this 00:23:48
Si el objeto que está 00:23:50
Que está implementando es menor 00:23:52
Que el objeto que te paso 00:23:54
Cero, si son iguales 00:23:55
O un número positivo 00:23:58
Si this es mayor 00:24:00
Que el objeto que te pasó 00:24:02
Esto me permite 00:24:04
Ordenar mis objetos 00:24:06
Por ejemplo, ordenar perros 00:24:08
Lo tienes que definir tú 00:24:10
Tú has creado los objetos perros 00:24:16
¿Cuándo un perro es menor que otro? 00:24:18
Lo tendrás que definir tú 00:24:23
Es exactamente el concepto 00:24:24
La comparable es un contrato que te está diciendo, oye, mira, si quieres implementar comparable, porque puedes no implementarlo, entonces tus perros no serán comparables. 00:24:26
Pero si tú quieres poder comparar dos objetos entre ellos y ordenarlos, por ejemplo, de mayor a menor, me tienes que definir tú cuál es el concepto de ordenado. 00:24:35
¿Cuál es? ¿Un perro menor o un perro mayor? ¿Lo haces por tamaño, por edad, por tamaño y edad? Elíjelo tú. 00:24:47
Y tendrás que dentro de compare to 00:24:54
Definir como se hace 00:24:57
Entonces darás tus cálculos y cosas por el estilo 00:24:58
Al final me darás un número negativo 00:25:00
Si el objeto 00:25:03
Que estás llamando este método 00:25:05
Es menor que el objeto 00:25:06
Que te he pasado de parámetro 00:25:08
Cero si son iguales 00:25:10
O positivo si yo soy mayor 00:25:12
Del objeto que me estás comparando 00:25:14
Con esta forma de aquí, con compare to 00:25:16
La cosa interesante es que hay un montón 00:25:18
De clases ya creadas 00:25:20
que te pillan un objeto comparable y, por ejemplo, te lo ordenan. 00:25:22
Entonces, cualquier objeto que vosotros creáis, el objeto gato, 00:25:30
implementáis el comparable y ya podéis utilizar un montón de métodos creados por otros 00:25:35
que te ordenan a raíz de gatos o a raíz de perros, sin tener que implementarlo vosotros. 00:25:44
¿Por qué? Porque usarán este 00:25:50
Comper2, ¿y cómo saben que yo 00:25:52
He creado Comper2? Porque implemento 00:25:54
Comparable, y si implemento Comparable 00:25:56
Esto tiene que estar 00:25:58
No sé si se entiende la potencia 00:25:59
De esto 00:26:02
Y hay un montón de cosas así 00:26:03
Hay Comparable, hay Serializable 00:26:06
Serializable 00:26:08
Quiere decir que sostantivamente 00:26:10
Puedo pillar mi objeto y transformarlo 00:26:12
En un array de bytes 00:26:14
Y si puedo hacer esto 00:26:16
Lo puedo mandar por internet, lo puedo escribir en un fichero 00:26:18
Lo puedo mandar a otro proceso 00:26:21
Puede hacer un montón de cosas 00:26:22
Si el objeto es serializable 00:26:24
Puede hacer un montón de cosas 00:26:26
Que no puede hacer si no es serializable 00:26:27
Tendré que mirarme 00:26:29
Que interfaz hay 00:26:35
Y para que sirven 00:26:37
Y en determinados casos para poder utilizar un método 00:26:38
Tendré que implementar una determinada 00:26:41
Interfaz 00:26:43
Haremos más ejemplos sobre todo con comparable 00:26:44
Porque luego nos servirán para el siguiente tema 00:26:47
Que son las colecciones 00:26:49
Duda 00:26:50
Esta de aquí 00:26:51
Lo pone por aquí, creo 00:27:01
Si los dos 00:27:02
Si la interfaz 00:27:06
Si tú intentas comparar 00:27:09
Un gato y un perro 00:27:11
Lo que deberías hacer es explotar 00:27:12
Y lanzarte probablemente una infección 00:27:14
No te puede decir, no, un gato y un perro son un en menor, un en mayor o son iguales 00:27:16
Porque no son comparables 00:27:21
Entonces debería explotar un tipo de excepción por algún lado 00:27:23
Hemos hecho las excepciones todavía, ya lo queremos 00:27:28
Ya está 00:27:30
Seguimos luego 00:27:35
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
11
Fecha:
19 de febrero de 2024 - 13:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′ 40″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
76.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid