Saltar navegación

Interfaces - 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 31 de enero de 2023 por Stefano C.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, por lo tanto, si habláis me dais autorización a que se grabe vuestra voz. 00:00:00
Hoy vamos a ver un poquito más del tema de... 00:00:09
Hemos estado repasando, hemos visto las clases astratas, el concepto de polimorfismo, 00:00:13
y ahora vamos hacia otra pieza del puzzle, que son las interfaces. 00:00:19
El discurso es que hasta ahora, cuando hemos hablado de clases astratas, 00:00:25
La clase abstracta es una mezcla entre cosas concretas, ¿vale? 00:00:29
Métodos concretos que yo implemento y otros métodos que no puedo implementar 00:00:35
porque todavía estoy a un nivel demasiado genérico y por lo tanto lo dejo abstracto 00:00:41
y alguien que extenderá esta clase podrá implementarla, ¿vale? 00:00:48
Si llevamos esta cosa al extremo 00:00:53
¿Vale? 00:00:57
Es decir, si tengo una clase 00:00:58
Astrata 00:01:00
Que no tiene nada concreto 00:01:01
Que solo tiene métodos abstractos 00:01:03
Pues ese señor 00:01:06
Es un interfaz 00:01:07
¿Vale? 00:01:09
Entonces, un interfaz al fin y al cabo 00:01:10
Es como una clase abstracta 00:01:12
Donde, pero es talmente abstracta 00:01:13
Que yo no puedo concretar nada 00:01:16
Ni siquiera variable 00:01:18
Ahora veremos luego las variables 00:01:19
Que puedo concretar 00:01:20
Entonces llega un momento en que digo, vale, todos los métodos aquí que estoy declarando son abstractos 00:01:21
Al punto que, a este punto, no me compensa poner abstracto en todos los métodos 00:01:26
Asumo que son todos abstractos, ¿vale? 00:01:31
Entonces, en vez de declarar una clase, declaro una interfaz 00:01:33
Si yo declaro una interfaz, todos los métodos que declararé ahora mismo, que veremos 00:01:37
Pues, sustancialmente, serán prototipos de métodos y serán considerados todos abstractos 00:01:42
No se le pone el cuerpo del método 00:01:48
Una clase lo que podrá hacer es implementar una interfaz 00:01:52
Cuidado, las interfaces no se extenden 00:02:00
Se pueden extender para hacer otras interfaces 00:02:03
O sea, interfaces entre ellos se pueden extender 00:02:05
Pero el concepto es que si creo una clase 00:02:07
Que va a implementar los métodos de esta interfaz 00:02:10
No la extendo la interfaz, la implemento 00:02:14
Tengo una palabra clave que ahora veremos que es implement 00:02:18
La cosa interesante de Java es que tú puedes extender una sola clase 00:02:21
Pero puedes implementar todas las interfaces que quieres 00:02:28
Es un poco, digamos así, una forma de crear en Java una herencia múltiple 00:02:32
Es la forma de cómo en Java podría hacer una herencia múltiple 00:02:44
Hemos dicho que en Java podría dar una sola clase 00:02:51
Por lo tanto, si en un determinado momento debería importar varios conceptos distintos dentro de la misma clase 00:02:54
Lo que puede hacer es extender una clase e importar varias interfaces 00:03:01
Esto es un poquito en general para entender qué es la interfaz 00:03:07
Vamos a ver qué dice 00:03:12
Es un concepto similar a la clase astrata 00:03:13
¿Vale? 00:03:16
Es un molde que define 00:03:16
Una estructura formal de métodos 00:03:19
Para una clase 00:03:22
¿Vale? Es decir, me está diciendo 00:03:23
Mira, esta... 00:03:24
Si tú implementas esta interfaz 00:03:27
Quiere decir que tu clase 00:03:29
Necesariamente tiene que tener 00:03:30
Este método, este método, este método 00:03:33
¿Vale? 00:03:34
Que devuelva esto, que pille este parámetro 00:03:36
Que se llame así, etc, etc 00:03:38
Es un contrato 00:03:40
Que yo hago contigo 00:03:42
Diciendo en el momento en que implementas 00:03:44
Mi interfaz 00:03:46
Esta interfaz aquí concreta 00:03:49
Yo sé que tu clase tendrá este método 00:03:50
Y por lo tanto hasta si 00:03:53
Yo no sé como está implementado 00:03:54
Esto lo implementarás tú 00:03:56
Dependiendo de tus casos específicos 00:03:58
Pero yo podré utilizar 00:04:00
Tú has creado el método 00:04:01
Dentro de 00:04:05
Dentro de una interfaz 00:04:07
Yo no sé como está implementado 00:04:10
Pero sé que si tu clase 00:04:12
Implementa esta interfaz 00:04:14
Yo puedo llamar sobre tus objetos 00:04:15
Método X 00:04:17
Y que devolverá lo que te he dicho 00:04:18
Que devuelva 00:04:22
Claramente la idea es que el contrato 00:04:23
También explique 00:04:26
Que tiene que hacer este método 00:04:27
¿Vale? Entonces normalmente 00:04:29
Va asociado la interfaz 00:04:31
Con sus varios métodos 00:04:33
Que tiene que implementar y cada método 00:04:35
Una descripción de lo que se espera de este método 00:04:37
¿Vale? Haremos un ejemplo concreto 00:04:39
Con la interfaz comparable 00:04:41
Dentro de un rato 00:04:44
¿Sí? 00:04:45
Sirven para presentar un mecanismo 00:04:48
Similar a la herencia múltiple 00:04:50
De otros objetos 00:04:51
De lenguajes orientados a objetos 00:04:52
T++, por ejemplo 00:04:54
Que es otro lenguaje orientado a objetos 00:04:56
Sí que admite herencia múltiple 00:04:59
Puedes hacer una extend, entre comillas 00:05:01
De varias clases 00:05:03
Ellos lo permiten 00:05:04
Se parecen a clases abstractas 00:05:08
Pero la diferencia es que 00:05:10
sus métodos son obligatoriamente 00:05:12
abstractos, o sea, no puede 00:05:14
hacer métodos concretos, en realidad 00:05:16
sí, ahora lo veremos, pero 00:05:18
los métodos por defecto de una interfaz 00:05:19
se consideran 00:05:22
abstractos, y por lo tanto 00:05:23
no voy a escribir abstracto por 00:05:26
todo lado, porque sé que si lo 00:05:28
declaro así normalmente, pues 00:05:30
ese es abstracto 00:05:32
¿no? 00:05:35
En Java, en vez de utilizar 00:05:38
class para crear una interfaz 00:05:40
Utilizo la palabra interface 00:05:42
Si habéis notado 00:05:44
Si os habéis parado alguna vez a mirar 00:05:45
Cuando en Eclipse pinchamos botón derecho 00:05:47
Y normalmente elegimos 00:05:49
O project, o package, o class 00:05:51
Lo que hemos utilizado hasta ahora 00:05:54
Pues también da la opción 00:05:56
Interface 00:05:57
En ese caso si pincháis allí 00:05:59
En vez de salir un public class no se que 00:06:01
Os saldrá un public interface 00:06:04
No se que 00:06:06
Y para 00:06:08
Para enlazar una clase con otra, o con una interfaz, en vez de decir que la clase extiende la otra clase, que es lo que se usa para la herencia, se dice que la clase implements esa interfaz. 00:06:11
Y lo que hemos dicho es que se puede extender una sola, se puede implementar varias. 00:06:29
Se pueden declarar referencias a objetos cuyo tipo sea una interfaz. 00:06:36
¿Vale? En lugar de una clase 00:06:40
O sea que si yo tengo la interfaz 00:06:41
Comparable 00:06:44
¿Vale? Comparable 00:06:52
¿Vale? Yo puedo crear 00:06:53
Una 00:06:56
Una variable 00:06:56
Comparable, para hacer comparable 00:06:59
X es igual a new 00:07:01
Algo, este 00:07:04
New algo que hago, esta nueva clase 00:07:05
Que estoy creando, esta instancia 00:07:08
Tendrá que ser una instancia que 00:07:09
Implementa comparable 00:07:11
Si no, no lo puedo hacer 00:07:13
Entonces si yo tengo 00:07:14
Las clases A, B y C 00:07:17
Y las tres clases 00:07:19
Implementan comparables 00:07:21
La clase A, B y C 00:07:22
Y las tres implementan comparables 00:07:24
Yo puedo crear tranquilamente un comparable 00:07:26
X es igual a 00:07:29
New A 00:07:31
Por ejemplo 00:07:33
Porque como A implementa comparables 00:07:33
Pues lo puedo hacer 00:07:36
Es parecido al concepto 00:07:37
Que hemos visto de 00:07:40
Upcasting en 00:07:41
En las clases abstractas 00:07:43
Si yo esta la pienso como una clase abstracta 00:07:47
Pues esto es una cosa 00:07:49
Que se podría hacer 00:07:51
O sea, puedo crear un nuevo A 00:07:53
Que extienda comparables 00:07:55
Y puede comparar el poder abstracto 00:07:57
Como hemos dicho que esto de la interfaz 00:07:58
Es como un paso más hacia la abstracción 00:08:00
Con respecto a la clase abstracta 00:08:03
La clase abstracta puede tener todavía 00:08:05
Algunos métodos implementados 00:08:06
Mientras esta no 00:08:08
El concepto es el mismo 00:08:09
¿Sí? ¿Dudas? 00:08:13
Sí 00:08:16
Yo puedo hacer que A extenda de animal 00:08:16
Y implemente con parámetros 00:08:25
Su función principal 00:08:28
Es establecer 00:08:35
Y estabilizar 00:08:36
¿Qué quiere decir? 00:08:39
Las interfaces por tipo de métodos 00:08:39
¿Vale? 00:08:42
Es que una clase puede ser de la realidad 00:08:44
Y así coordinar varios equipos de trabajo 00:08:45
¿Para qué sirve una interfaz de verdad? 00:08:47
La idea es que cuando yo tengo un proyecto relativamente complejo 00:08:52
Necesito de alguna forma organizar los varios equipos de trabajo 00:08:56
Que están trabajando sobre el sistema 00:09:00
Es muy ineficiente pillar un grupo de trabajadores 00:09:02
De 50 trabajadores y decir 00:09:06
Vosotros desarrolláis todos, ahí va, todos juntos, venga 00:09:08
Necesito repartir estos trabajadores en varios módulos 00:09:11
De mi sistema 00:09:16
Y que cada uno de estos trabajadores 00:09:18
Se ocupe de desarrollar ese módulo en concreto 00:09:20
El problema surge 00:09:22
Cuando estos módulos tienen que comunicar entre ellos 00:09:24
Y yo tengo que utilizar 00:09:27
Objetos que están siendo desarrollados 00:09:28
Por otro equipo 00:09:31
¿Vale? 00:09:32
Para estar seguro de que puede 00:09:33
Mi equipo 00:09:36
Utilizar sobre los otros 00:09:38
Objetos, lo que puedo utilizar 00:09:40
Es una interfaz 00:09:42
Yo no te estoy diciendo como se hará 00:09:43
estas cosas. Te estoy diciendo 00:09:46
que un objeto que implemente 00:09:48
esta interfaz, seguramente 00:09:51
tendrá el método calcular 00:09:52
y calcular perímetro. 00:09:54
Entonces, tú puedes 00:09:57
crear los objetos que quieras 00:09:58
de este tipo, de tipo comparable, 00:10:00
utilizar métodos que 00:10:03
llamen, que pillen como parámetro 00:10:04
un objeto comparable 00:10:07
y tú sabes que sobre el método 00:10:08
comparable, sobre el objeto comparable, 00:10:10
podrás llamar calcular 00:10:12
y calcular perímetro. 00:10:14
¿Cómo está hecho? No lo sé 00:10:16
Lo implementará el otro equipo 00:10:18
Pero yo estoy seguro 00:10:21
Que puedo llamar esta lista 00:10:22
De métodos 00:10:24
Y sé que hace cada uno de estos métodos 00:10:25
Porque la interfaz me lo explica 00:10:28
Cuando tú usas estos métodos 00:10:30
Le pasarás este parámetro 00:10:32
Y obtendrás de vuelta este valor 00:10:34
Calculado o no se sabe cómo 00:10:36
Eso lo implementarán ellos 00:10:38
A lo mejor para calcularlo tengo que acceder a una base de datos 00:10:39
Acceder a un fichero, mezclar la base de datos 00:10:42
El fichero 00:10:44
Ir a hacer una conexión con otro servidor 00:10:45
No lo sé, no me interesa 00:10:48
Yo sé solo que si amo este método 00:10:49
Me resuelve lo que tiene que resolver 00:10:51
Esto tiene una potencia tremenda 00:10:53
A la hora de modulizar mi sistema 00:10:59
Yo tengo que poner de acuerdo 00:11:01
Los varios grupos de trabajo 00:11:04
Sobre lo que es la interfaz 00:11:06
Donde son los puntos, digamos, de contacto 00:11:08
Entre un módulo y otro 00:11:11
Entre unas clases y otras 00:11:13
Y explicarles 00:11:15
Qué pueden hacer con estos objetos 00:11:17
Luego ellos 00:11:19
Lo llamarán sin problemas 00:11:20
¿Vale? Cuando luego todo será 00:11:22
Organizado y será creado 00:11:25
Pues entonces yo al llamar 00:11:27
Los métodos, en vez de llamarlos 00:11:29
Pasándole un objeto comparable 00:11:31
Que no existe el objeto comparable porque es una interfaz 00:11:33
Le pasaré uno de los objetos 00:11:35
Que implementan comparable 00:11:37
Y en automático ello funcionará 00:11:39
No sé si 00:11:41
Luego hacemos ejemplos 00:11:42
Pero por ahora 00:11:45
Si os interesa 00:11:47
¿Vale? 00:11:49
El equipo que debe utilizar objetos 00:11:52
Este es más o menos la explicación de lo que acabo de decir ahora 00:11:54
Que implemente dicha interfaz 00:11:56
Basta con que declare en su código 00:11:58
Una referencia a dicha interfaz 00:12:00
Si yo tengo esta interfaz 00:12:01
No necesito crear un objeto 00:12:03
Que implemente esa interfaz 00:12:05
Sino que declaro una referencia 00:12:08
A esa interfaz 00:12:10
Ante la interfaz, como por ejemplo comparableX 00:12:11
¿Vale? 00:12:14
Y en automático puedo llamar sobre X 00:12:15
Todos los métodos de la interfaz 00:12:17
¿Dónde estará su implementación? 00:12:18
Pues su implementación dependerá que luego 00:12:21
Cuando yo asocio esta referencia 00:12:23
A un objeto que implementa 00:12:25
Esa interfaz 00:12:27
Tendrá un 00:12:28
El método 00:12:30
Especificado e implementado 00:12:32
Y por polimorfismo, cuando yo llamo 00:12:35
Este método, no se llamará sobre la interfaz 00:12:37
Que no existe, sino se llamará 00:12:39
sobre la instancia, que será 00:12:41
un objeto que sí tiene 00:12:43
implementado ese método. Entonces 00:12:45
funcionará. Es más de 00:12:47
lo mismo de lo que hemos visto con las clases abstractas. 00:12:49
¿Vale? Utilizando el 00:12:52
polimorfismo, esto funciona. 00:12:53
Si no hubiese polimorfismo, tendríamos 00:12:55
un problema. Los equipos 00:12:57
que creen clases que 00:12:59
implementen dicha interfaz 00:13:01
están a su vez desacoplados 00:13:03
de los equipos que lo utilizan. ¿Vale? 00:13:05
Esto es un concepto 00:13:07
de desacoplar el trabajo. O sea, 00:13:09
separar, individualizar 00:13:11
e independizar en un cierto sentido 00:13:13
el trabajo de un equipo 00:13:15
de trabajo y de otro 00:13:17
la ventaja de poner una interfaz 00:13:18
en el medio es que por un lado 00:13:21
puedo trabajar la implementación de esa 00:13:23
interfaz y eso es un equipo de trabajo 00:13:25
y por otro lado ya utilizar 00:13:27
esa interfaz sin necesidad de tener 00:13:29
una implementación 00:13:31
real 00:13:33
que me proporcionará más adelante 00:13:33
¿se entiende? 00:13:37
La idea es que podría haber un caso específico o casos específicos 00:13:39
En que el equipo A, que es el que implementa la interfaz, está haciendo su trabajo 00:13:46
Y que haya un equipo B que quiere utilizar esa interfaz 00:13:53
Y por lo tanto está utilizando Comparable en general y está utilizando sus métodos 00:13:58
Pero este equipo B necesita realmente un objeto para poder funcionar 00:14:03
¿Vale? Porque algunos de los métodos no se basan solo sobre comparable, sino que tienen que llamarlos estos métodos y funcionar. 00:14:09
¿Vale? Entonces, en casos como estos, Java proporciona los objetos mock, que nosotros por ahora no veremos, a lo mejor lo veremos más adelante, pero que os suelen como concepto. 00:14:19
Un objeto mock es un objeto falso 00:14:31
Es un objeto que no es verdad 00:14:35
No es un objeto real que luego voy a utilizar 00:14:38
Es un objeto falso que implementa en un cierto sentido 00:14:42
La interfaz 00:14:47
Pero me devuelve por ejemplo valores fijos 00:14:52
O valores muy sencillos 00:14:55
En vez de estar haciendo el acceso a la base de datos 00:14:57
el acceso al fichero 00:14:59
que decíamos antes, combinarlos y cosas por estilo 00:15:01
que no tengo todavía listo 00:15:04
porque todavía en eso está 00:15:05
trabajando el otro equipo de desarrollo 00:15:07
pues hago que 00:15:09
si tú llamas este método te devuelvo 3 00:15:11
y ya está 00:15:13
claramente cada vez que lo utilizaré 00:15:16
recibiré 3 00:15:18
pero recibiré un posible 00:15:19
valor real 00:15:22
de esa 00:15:23
interfaz 00:15:26
de ese método 00:15:27
Entonces es un poquito más complejo que esto 00:15:28
Pero a esta altura 00:15:32
Tampoco tiene mucho sentido 00:15:34
Meter ese tipo de complejidad 00:15:35
Porque por ahora esto no lo vamos a utilizar nosotros 00:15:37
Esto simplemente para que os suene 00:15:39
El concepto de mock object 00:15:41
Que en un futuro 00:15:43
Estáis trabajando y alguien dice 00:15:44
Que aquí para poder 00:15:46
Hacer el trabajo tenemos que hacer un objeto mock 00:15:48
Y que vosotros no sabáis hacerlo 00:15:51
Pero que sepáis que existe 00:15:53
Y digáis, si me acuerdo de una vez 00:15:55
Un tío que hablaba mal 00:15:57
Me ha comentado algo de eso 00:15:58
¿Vale? 00:16:00
Si tenemos tiempo más adelante 00:16:02
A lo mejor 00:16:04
Ejemplo de interfaz 00:16:05
¿Vale? Por ejemplo 00:16:08
Un ejemplo muy interesante de interfaz 00:16:09
Es la interfaz comparable 00:16:12
¿Vale? Esta interfaz 00:16:14
No la he creado yo 00:16:16
Existe en Java 00:16:17
Si vosotros os vais 00:16:19
Si vosotros os vais a LAPI 00:16:21
Y buscáis comparable 00:16:24
Os sale la interfaz comparable 00:16:25
Que incluye toda la información 00:16:28
Sobre qué es la interfaz comparable 00:16:31
Cómo se utiliza, para qué sirve, etc. 00:16:34
El concepto es que una interfaz comparable 00:16:37
Tiene un método 00:16:39
Este método de aquí 00:16:40
int compareToObjecto 00:16:42
Esto es un método que 00:16:45
Te devuelve un entero 00:16:49
Se llama compareTo 00:16:50
Y recibe otro objeto 00:16:52
Tú lo llamarás sobre un objeto 00:16:54
Y luego le pasas otro objeto como parámetro 00:16:55
Entonces, aquí hay dos objetos en el medio 00:16:59
El objeto que llama este método 00:17:02
Mi objeto actual 00:17:05
Y el objeto que le paso para comparar 00:17:07
Porque claramente comparar tú 00:17:09
Estoy comparando 00:17:11
¿Y qué me dice que tiene que hacer este método? 00:17:12
Este método tiene que devolver un entero 00:17:16
Y este entero tiene que ser 00:17:18
Un número negativo 00:17:19
Por ejemplo, menos uno 00:17:21
Si el objeto dis 00:17:22
El objeto sobre el que le estoy llamando 00:17:26
Es menor 00:17:29
Que este objeto que le he pasado como parámetro 00:17:30
Devuelve cero 00:17:33
Si los dos son iguales 00:17:36
Y devuelve un número positivo 00:17:39
Por ejemplo uno 00:17:42
Si dis 00:17:43
El objeto sobre el que estoy llamando 00:17:45
Es mayor 00:17:47
Que el objeto 00:17:49
En cuanto a tu definición de mayor y menor 00:17:51
Tú tienes el objeto gato 00:17:59
¿Cuándo el objeto gato1 que has creado tú es menor que el objeto gato2? 00:18:02
Lo tienes que definir tú 00:18:11
Oye, pero los gatos no son comparables 00:18:13
Pues entonces no implementas la interfaz comparable 00:18:16
Si tú implementas la interfaz comparable 00:18:19
Implicitamente le estás diciendo que tu clase está adquiriendo una nueva propiedad 00:18:22
En un cierto sentido que es comparable entre objetos de esa clase 00:18:28
Y como son comparables los objetos de otra clase 00:18:34
Tú tendrás que tener en tu mente una idea para poderlo comparar 00:18:38
¿Cómo se comparan dos gatos? 00:18:42
No lo sé 00:18:45
¿Vale? 00:18:46
¿Su edad? 00:18:47
Pues entonces un gato más viejo es mayor que un gato más joven 00:18:48
Vale, fenomenal 00:18:52
Y entonces ahora ya tienes una forma de implementar esto 00:18:53
En tu implementación de Compartoo mirarás el disk que será un gato 00:18:56
¿Cuántos años tiene? 00:19:02
El objeto los downcastarás a un gato siempre y cuando sea un gato 00:19:04
Y mirarás su edad 00:19:10
Y a ese punto devolverás menos uno 00:19:13
si la edad del tuyo es 00:19:16
menor que la edad de O 00:19:18
le devolverás 00:19:19
0 si la edad es la misma 00:19:21
puede ser más complejo 00:19:23
puede ser que un gato sea 00:19:26
mayor si 00:19:27
es más joven 00:19:29
o menor, es más joven y es más pequeño 00:19:31
porque hay también talla 00:19:34
y allí hay varias cosas 00:19:35
tú puedes complicar esta 00:19:37
convertu, cuanto te dé la gana 00:19:39
en la base de cómo 00:19:41
tú ordenas los objetos 00:19:44
¿Y cualquier objeto tiene que ser ordenable? 00:19:45
¿Vale? 00:19:50
Todos los objetos que hemos estado haciendo hasta ahora 00:19:52
No implementaban este comparable 00:19:55
Por lo tanto, ¿cómo los ordenamos? 00:19:57
No lo sé, no tengo ni idea 00:19:59
¿Vale? 00:20:01
Ahora 00:20:02
Si yo quiero implementar este compareTo 00:20:02
Entonces implementar compareable 00:20:06
¿Vale? 00:20:08
Necesito que en mi clase 00:20:10
esté definida 00:20:13
una idea de cómo se ordenan 00:20:15
estos objetos 00:20:18
¿vale? por ejemplo, una persona 00:20:19
pues lo ordeno por su DNI 00:20:22
miro el DNI 00:20:24
y si el DNI pasado a 00:20:25
número es menor 00:20:28
que el otro, pues entonces 00:20:30
declararé que es menor el objeto 00:20:31
y si no es mayor, no lo sé 00:20:34
depende de vosotros y de lo que estáis implementando 00:20:35
¿vale? puede que haya 00:20:38
cosas, si yo estoy haciendo la clase 00:20:40
integer 00:20:42
Que representa interos 00:20:43
Que existe, está en Java 00:20:45
¿Vale? 00:20:47
Y que es un objeto que dentro tiene un int 00:20:48
Y que sustantivamente hace 00:20:50
Como un wrapping 00:20:52
Hace como un 00:20:53
Un vectorio 00:20:57
De el número int 00:20:59
Como primitivo y lo transforma en un objeto 00:21:03
Integer que representa 00:21:05
Ese número 00:21:06
¿Vale? Lo veremos 00:21:08
Bueno, lo hemos usado una vez con integer.parse 00:21:09
Debe sonar 00:21:12
Esa es la clase integer 00:21:14
Que es un objeto que representa un entero 00:21:16
¿Sí? 00:21:19
¿Cómo ordeno los enteros? 00:21:20
Es muy fácil 00:21:22
Miro su valor 00:21:23
Y su valor, si es menor que el otro entero 00:21:25
Pues es menor 00:21:27
Si es mayor, es mayor 00:21:29
Y si son iguales, pues es cero 00:21:31
Ordenar un entero es muy fácil 00:21:33
Ordenar un gato 00:21:36
O ordenar un animal 00:21:38
Puede ser más complejo 00:21:39
Y a lo mejor no tiene sentido 00:21:41
Ordenar un animal 00:21:43
¿Dudas? 00:21:45
Entonces 00:21:50
¿Y por qué debería yo 00:21:50
Molestarme con 00:21:53
La interfaz comparable 00:21:55
¿Cómo se dice? 00:21:58
Implementarla y perder tiempo en crear 00:22:00
Este objeto aquí cuando podría 00:22:03
Tranquilamente crearme mi propio 00:22:05
Comparar gatos 00:22:07
Y ponerla ahí 00:22:09
Porque en el ecosistema de Java, en el API, en todas las clases ya creadas que tenéis vosotros 00:22:10
Hay clases que funcionan sobre objetos Convertible 00:22:18
Es decir, que funcionan sabiendo que sobre los objetos de tipo Convertible pueden llamar el Convertu 00:22:24
Y entonces si tú te haces una clase que implementa Convertible 00:22:33
Automáticamente puedes utilizar todos esos métodos ya creados 00:22:38
Sobre objetos de tu clase 00:22:43
Si en vez tú no la implementas, no 00:22:45
El ejemplo típico que haremos dentro de un rato 00:22:49
El sort 00:22:52
El sort sirve para ordenar 00:22:53
Imaginamos que vosotros tenéis un array de objetos 00:22:57
Y los queréis ordenar 00:23:00
Para ordenarlos necesitáis un orden 00:23:01
Que sean posibles de comparar entre ellos 00:23:06
Si no, puedes comparar como los dos 00:23:10
Entonces, existen métodos ya hechos 00:23:12
Arrays.sort, por ejemplo 00:23:17
Que te pillan un array 00:23:20
Y te devuelven un array 00:23:22
El mismo array ordenado 00:23:23
Pero el objeto que te pillan 00:23:25
Para poder hacer eso 00:23:28
Necesariamente tiene que ser de tipo comparable 00:23:30
Con eso ellos se aseguran 00:23:33
Que para poder funcionar el ordenamiento 00:23:36
Ellos pueden llamar 00:23:39
Dentro el compareTo 00:23:41
Y empezar a comparar los objetos 00:23:42
Que están dentro de esta array 00:23:45
Con el fin de decir 00:23:46
Al final de todo este trabajo 00:23:48
Pues te he ordenado la array 00:23:50
Si no se pueden comparar entre ellos 00:23:51
¿Qué puedo hacer? 00:23:54
¿Me explico? 00:23:58
Es más 00:24:00
Si yo en vez de haber utilizado la interfaz compareMode 00:24:00
Utilizo mi propio método 00:24:03
Comparar gatos 00:24:05
Que nadie conoce 00:24:06
Pues la función sort 00:24:08
Creada ya por otros desarrolladores 00:24:10
No puede 00:24:12
Adivinar que yo he creado 00:24:14
Comparar gatos 00:24:16
No me va a funcionar 00:24:17
Pero lo que puede hacer es decir 00:24:19
Mira, oye, yo me baso sobre una interfaz 00:24:22
Esta interfaz de aquí, comparable 00:24:24
Y sé que si tú implementas 00:24:26
Esta comparable, habrás tenido 00:24:28
Que implementar el compareTo 00:24:30
Que dará 00:24:32
exactamente este tipo de resultados 00:24:34
negativo, cero 00:24:36
o positivo, y yo podré 00:24:38
entender 00:24:40
estos números que me das 00:24:41
para poder ayudarte 00:24:44
a ordenar, independientemente 00:24:46
de cual sea 00:24:48
tu objeto 00:24:50
si tú has hecho el objeto animal que implementas 00:24:52
con parable, yo te lo puedo ordenar 00:24:54
si tú has hecho el objeto vehículo que implementas 00:24:56
con parable, yo te lo puedo ordenar 00:24:59
porque tú al fin y al cabo 00:25:00
Cuando implementas comparable 00:25:02
Lo que me estás dando es un criterio 00:25:04
Para ordenar 00:25:06
Una forma de comparar dos objetos 00:25:07
De tu clase y decir 00:25:10
Cuál viene antes y cuál viene después 00:25:12
Y sobre esta base yo puedo hacer 00:25:14
Ordenación 00:25:16
Este es un ejemplo 00:25:18
Muy importante de cómo funcionan 00:25:21
Las interfaces 00:25:24
Yo he creado toda una serie de métodos 00:25:25
Que se basan sobre el hecho que 00:25:28
Tú me has dado un criterio de comparación 00:25:29
Y yo hago todos mis métodos 00:25:32
Basándome sobre ese criterio 00:25:34
Cualquier método que implemente 00:25:35
Esa interfaz, también podrá utilizar 00:25:38
Todos mis métodos 00:25:40
¿Dudas? 00:25:42
Hay varias interfaces ya existentes 00:25:49
Y algunas de ellas 00:25:52
La iremos viendo, ¿vale? 00:25:53
Por ejemplo, con Parable lo utilizaremos 00:25:55
También está otra que se llama 00:25:57
Serializable 00:25:59
Serializable 00:26:02
¿Vale? 00:26:04
Serializable quiere decir que tú puedes 00:26:05
Pillar un objeto y trocearlos 00:26:07
En byte 00:26:10
Y mandarlo byte a byte 00:26:11
La cosa interesante de eso 00:26:14
Es que luego puedes guardar objetos 00:26:16
En un fichero 00:26:18
O mandar objetos 00:26:19
En internet 00:26:21
A otro ordenador 00:26:23
¿Vale? 00:26:25
Si la clase que tú haces implementa 00:26:27
Serializable, entonces yo le enseño 00:26:29
Cómo se puede 00:26:32
Trocear a byte 00:26:34
Mi objeto 00:26:35
Pues entonces automáticamente 00:26:37
Aquí te da la posibilidad de ser guardado en un fichero 00:26:39
No los carácteres 00:26:42
El objeto 00:26:45
No sé si entendéis la diferencia 00:26:46
Que luego puede llegar otro programa 00:26:47
Y pillarse el objeto 00:26:49
No los carácteres que representa 00:26:52
O no el gasto 00:26:54
El objeto que tú has guardado 00:26:56
Si tu clase es serializable 00:26:57
Es decir que luego tú podrás utilizar 00:27:05
El método que sea 00:27:07
Para poder escribir un fichero y leerlo 00:27:08
Pero el objeto es serializable 00:27:10
Es la misma clase 00:27:12
Si tienes un gato serializable 00:27:13
Y guardas el gato 00:27:15
Pues para sacarlo tendrás que tener la misma clase 00:27:17
Y decir, oye mira saco un objeto de esta clase 00:27:19
¿Vale? 00:27:22
Aún así, esto es cosas avanzadas 00:27:23
Las veremos cuando veremos persistencia de objetos 00:27:25
Y veremos como se guardan las cosas en ficheros 00:27:27
¿Vale? 00:27:30
Y será cosa que es de tercero 00:27:31
¿Vale? 00:27:32
Otra cosilla, ¿os acordáis que en Object existía un método que se llama Equals? 00:27:42
¿Vale? 00:27:49
Que era para ver si dos objetos son iguales 00:27:50
Cuidado, que si yo implemento Comparable 00:27:53
Y entonces doy una definición de cuando dos objetos son iguales 00:27:56
Porque tengo que devolver un cero cuando son iguales 00:28:02
Pues esta definición tiene que ser consistente con la implementación del Equals 00:28:05
Equals me tiene que dar true 00:28:12
Cuando esto me da cero 00:28:17
Y solo cuando esto me da cero 00:28:21
No puedo tener casos en el que esto me dice 00:28:23
Si son iguales y luego voy al equals 00:28:27
Y me dice falso 00:28:29
Sería un problema 00:28:30
Crearía inconsistencias en que si estoy comparando 00:28:32
Dos objetos que lo compares tú 00:28:35
Me dice si son el mismo 00:28:36
Y si lo intento comparar con el equals 00:28:37
Me dice no son distintos 00:28:39
Entonces cuidado también 00:28:40
Que como 00:28:43
Os acordáis que el equals por defecto 00:28:44
El equals de object 00:28:47
Compara las referencias 00:28:48
Si yo voy a implementar 00:28:51
El comparable con compareTo 00:28:54
Entonces estoy implementando esto de aquí 00:28:55
Pues lo más probable 00:28:57
Que tendré también que sobre escribir 00:28:59
Override el equals 00:29:01
Para que sea consistente 00:29:04
Si dejo el equals de object 00:29:05
Y implemento el compareTo 00:29:09
Para mis objetos 00:29:12
Lo más probable es que luego no sean consistentes 00:29:13
Porque estoy comparando cosas distintas 00:29:16
Habíamos dicho que los gatos comparaban su edad 00:29:19
Mientras el equals de object 00:29:21
Compara si son la misma referencia 00:29:23
Por lo tanto, darían cosas distintas 00:29:25
Si yo tengo dos gatos de la misma edad 00:29:27
Que son dos objetos distintos 00:29:29
CompareTo me daría cero 00:29:31
Porque tienen la misma edad 00:29:32
Y equals me daría falso porque son objetos distintos 00:29:34
Eso no puede pasar 00:29:36
Un ejemplo práctico de interfaz 00:29:39
Vamos a verlo 00:29:54
Entonces aquí tenemos 00:29:55
Una interfaz animal 00:29:57
Aquí 00:30:00
Mi interfaz animal 00:30:02
Que estará en un fichero 00:30:05
Tiene el método habla 00:30:07
Que devuelve nada 00:30:10
Aquí debería explicar 00:30:12
Que hace habla 00:30:14
Que cuando habla un animal 00:30:15
Pues hace su sonido 00:30:16
Sea cual sea 00:30:18
Entonces 00:30:19
Esto quiere decir que cualquier 00:30:22
Clase que implemente animal 00:30:26
Tiene que implementar 00:30:29
Habla 00:30:31
Si no, me da un error 00:30:31
Entonces me voy a crear perro 00:30:33
Public class perro 00:30:36
Implements animal 00:30:40
Este es otro fichero 00:30:43
Si os fijáis aquí no pongo extends 00:30:44
Pongo implements 00:30:47
Se puede extender una cosa 00:30:48
Y implements varias cosas 00:30:54
Mientras extends 00:30:57
Siempre es una sola clase 00:30:59
Extendo una clase 00:31:00
Pero puedo implementar cuantas clases me da la gana 00:31:02
Cuantas interfaces 00:31:05
Entonces aquí dentro 00:31:08
Yo puedo hacer lo que me da la gana con perro 00:31:09
Poner todas las variables que quiera 00:31:11
Todos los métodos que quiero 00:31:14
Pero necesariamente tendré que tener 00:31:15
Una implementación de 00:31:18
Habla 00:31:19
Igual a la de anterior, ¿vale? 00:31:21
En concreto, esto puede cambiar el public 00:31:23
¿Vale? No puede ser 00:31:26
Más restrictivo 00:31:28
¿Vale? 00:31:30
O sea que public lo puedo poner 00:31:32
Pero si intento poner aquí algo como 00:31:34
Private, me va a decir no 00:31:36
Porque la definición arriba no ponía 00:31:37
Public o no ponía private 00:31:40
¿Vale? 00:31:41
Entonces, ¿qué hace el método habla cuando es un perro? 00:31:42
Pues se escribe guau 00:31:47
Una fantástica implementación 00:31:48
Por otro lado, tengo gato 00:31:52
Que cuando implementa habla, porque él implementa animals 00:31:54
Por lo tanto, tiene que implementar el método habla 00:31:59
Y lo que hace es escribir miau 00:32:02
Cada animal dice lo suyo 00:32:05
¿Cómo se usa esto? 00:32:07
Entonces aquí tenemos una clase 00:32:09
Main 00:32:12
¿Vale? 00:32:14
En el que el main dice 00:32:15
Me creo un animal 00:32:17
¿Lo puede hacer esto? 00:32:19
Sí 00:32:22
¿Perro qué es? 00:32:23
Una clase 00:32:27
Y new perro es un 00:32:28
Instancia de tipo perro 00:32:30
Es un objeto 00:32:34
¿Sí? 00:32:35
¿Animal qué es? 00:32:36
Es una interfaz 00:32:38
Si os fijáis, aquí estoy utilizando el tipo de la interfaz como si fuera una variable 00:32:41
Interfaz no es ni siquiera una clase, ¿vale? 00:32:47
Pero lo hemos visto ya con las clases abstractas 00:32:51
Aquí lo que estamos utilizando es dando un tipo a esta interfaz 00:32:54
Que es un tipo más genérico de lo que es de verdad 00:32:57
Pero un perro cuando implementa un animal, ¿vale? 00:33:00
Cuando implementa la interfaz animal, un perro puede ser un animal 00:33:05
En este sentido lo que estamos diciendo es que cuando yo utilizo animal dog, por ejemplo aquí 00:33:08
Quiere decir que el objeto referenciado por dog implementa esa interfaz 00:33:14
Y por lo tanto, cuando usaré dog, podré usar todos los métodos que están definidos en la interfaz animal 00:33:21
No podré utilizar lo que está definido solo en perro 00:33:29
Si perro tuviera también otro 00:33:35
Método que es 00:33:39
Correr 00:33:41
Pues no lo podría utilizar 00:33:42
Porque desde animal 00:33:44
Correr no existe 00:33:46
Debería hacer un downcasting a perro 00:33:47
Y lo puede utilizar 00:33:50
Justo 00:33:52
Entonces 00:33:53
Yo quiero animal dog perro 00:33:56
Y animal dog gato 00:33:58
He creado dos animales 00:33:59
Y como tanto perro como gato 00:34:01
Implementan animal 00:34:04
Pues lo puedo crear así 00:34:05
Cuando llamaré dog.habla 00:34:06
Me escribirá 00:34:10
Cuando llamaré cat.habla 00:34:11
Me escribirá 00:34:16
Pero estos dos son animales 00:34:18
¿Cómo descubre 00:34:21
Cuáles de los métodos que tiene que utilizar? 00:34:23
Gracias al 00:34:26
Polimorfismo, nuestro mejor amigo 00:34:27
Vamos a ver 00:34:30
Otra cosa interesante 00:34:32
¿Vale? Me creo un array 00:34:35
De animales, esto ya lo hemos hecho 00:34:37
Es muy parecido a lo que hemos hecho con las 00:34:39
Trastes abstractas 00:34:41
¿No? Hasta ahora hemos estado trabajando más o menos así 00:34:43
Pongo 00:34:45
Dog en posición 0 00:34:47
Y cat en posición 1 00:34:49
Lo puedo hacer, fijaos que estoy 00:34:50
En un array de animal 00:34:53
Donde he metido dentro una referencia animal 00:34:54
Que en realidad es un perro 00:34:56
Y una referencia cat que es un animal 00:34:58
Que en realidad es un gato 00:35:01
Pero los puedo poner todo en animal 00:35:02
Porque tanto perros como gatos 00:35:05
Implementan la interfaz 00:35:06
Y luego lo que hago es 00:35:09
Que hablen todos 00:35:12
Y le paso este 00:35:13
Array 00:35:15
Que hables todo que es 00:35:17
Como 00:35:19
Estático 00:35:22
Cursiva 00:35:30
¿Cómo se llama? 00:35:32
Lo llamamos loco 00:35:33
¿Sí? 00:35:34
Este es un método estático porque estoy en el main 00:35:37
Para llamarlo, bueno, podría no ser estático 00:35:40
Si esto fuera un objeto, no pasaría nada 00:35:42
¿Vale? Lo que me interesa 00:35:44
Es que entendáis que le estoy pasando un qué 00:35:45
Un rey de qué 00:35:48
Un rey de animales 00:35:51
¿Sí? Aquí no hay gatos ni perros 00:35:53
Un rey de animales 00:35:56
Y de hecho, si os fijáis aquí 00:35:57
Lo que recibe él 00:36:00
Es un rey de animales 00:36:01
Me da igual que haya dentro 00:36:03
Esta cosa de aquí 00:36:06
Animal, array de animales 00:36:09
Me está diciendo que me van a pasar 00:36:11
Un array de objetos 00:36:14
Y los objetos que están ahí dentro 00:36:15
Todos cumplen con un requisito 00:36:18
¿Qué es? 00:36:20
Todos los que están ahí dentro 00:36:26
Tienen un requisito 00:36:28
Todos los arrays que estarán 00:36:30
Dentro de este array 00:36:32
Todos los objetos que estarán 00:36:34
Dentro de este array 00:36:37
Cumplen con un requisito 00:36:37
¿Qué es? 00:36:39
Implementan 00:36:39
La interfaz animal 00:36:42
¿Vale? Entonces en cualquier 00:36:45
Objeto de 00:36:47
Este array, ¿qué podré hacer yo? 00:36:49
Llamar 00:36:55
Los métodos de la interfaz animal 00:36:55
Y entonces aquí 00:36:57
Puedo tranquilamente hacer un for 00:37:01
¡Uy! ¿Qué es esto? 00:37:04
Sí, es una cosa que hemos visto 00:37:05
Y que se os ha olvidado porque no utilizáis nunca 00:37:07
¿Vale? Puedo pillar 00:37:09
Cada uno de los animales 00:37:11
Que están dentro de animales 00:37:13
Y decirle que hable 00:37:14
Este es equivalente a poner 00:37:16
Porinte igual a cero 00:37:19
Y menor que 00:37:22
Animales punto lente 00:37:24
Y más más 00:37:25
Y aquí poner animales de i 00:37:26
Punto habla 00:37:30
Fijaos que 00:37:31
Imaginaos que esta cosa 00:37:37
no lo hayáis creado vosotros 00:37:40
ma otro equipo de trabajo 00:37:42
necesitaba 00:37:44
el haber implementado 00:37:46
el método habla 00:37:48
para poder 00:37:50
hacer este código 00:37:52
vale, yo no sé 00:37:55
como se hace este método 00:37:58
yo lo único que sé es que como estoy 00:37:59
utilizando animal que es una 00:38:02
una interfaz y tú me has dado 00:38:04
la interfaz que es solo el prototipo 00:38:06
Yo sé que puedo llamar habla 00:38:08
Sobre todos los objetos de este array 00:38:10
Y lo llamo 00:38:13
Luego lo que hará 00:38:14
Cómo se hará y por qué se hará 00:38:16
Pues eso a mí no me importa 00:38:19
Lo está desarrollando otro equipo 00:38:20
Pero estoy seguro que lo puedo utilizar 00:38:22
Porque todos los objetos 00:38:28
Que están en este array 00:38:30
Son de tipo animal 00:38:31
Que quiere decir que están implementando la interfaz animal 00:38:32
Esto, sobre todo a nivel de diseño 00:38:35
Es una cosa muy potente 00:38:42
Muy interesante 00:38:44
Como nosotros nos centramos más en la implementación 00:38:44
Que en el diseño, muchas veces 00:38:48
En los exámenes o en los ejercicios 00:38:49
El diseño se lo doy yo 00:38:51
Os doy 00:38:52
Hacer tres clases, esta clase, esta clase 00:38:54
Os he dado ya el diseño 00:38:57
Pues entonces 00:38:59
A lo mejor os cuesta un poquito más 00:39:00
Ver la potencia de esta cosa 00:39:03
Pero en la realidad 00:39:05
Pues no lo tengo 00:39:06
Tanto para las interfaces que puedo crear yo 00:39:08
como es aquí, esta interfaz la he creado yo 00:39:11
como puede ser para interfaces 00:39:13
ya existentes a Java 00:39:15
como Compatible, Serializable 00:39:17
no sé cómo se dice en inglés 00:39:20
o Serializable o lo que sea 00:39:21
y hay muchas 00:39:23
también 00:39:24
repito un poquito lo que he dicho 00:39:27
antes, la cosa interesante es que 00:39:30
luego en el ecosistema de Java 00:39:31
en todas las clases que ya existen 00:39:33
que son muchas, muchas, muchas clases 00:39:35
muchas veces yo no sé 00:39:37
el objeto que vas a utilizar tú 00:39:40
Pero voy a utilizar 00:39:41
Interfaces ya existentes 00:39:43
Asumiendo que si tú 00:39:45
Implementas esa interfaz 00:39:47
Entonces, obviamente, a mí me estás dando herramientas 00:39:49
De algunos métodos que puedo llamar 00:39:51
Y por lo tanto yo puedo hacer 00:39:53
Un programa 00:39:55
General, como es este método 00:39:56
De aquí, el método que hablen todos 00:40:00
Basado sobre el hecho que 00:40:01
Tú habrás dado una implementación 00:40:03
De ese método 00:40:05
No sé cuál es, pero sé que lo tendrás 00:40:06
Y todo lo puedo utilizar 00:40:09
Y sé lo que tiene que hacer 00:40:10
La descripción de habla es que haga su sonido 00:40:12
Hay que calcular el área del triángulo 00:40:15
Entonces, basándome sobre eso 00:40:17
Puedo hacer cosas muy interesantes 00:40:20
Cuando yo entro en este mundo 00:40:22
Y tengo mi nuevo objeto nuevo 00:40:24
Que tengo que hacer algo con él 00:40:26
Y tengo un montón de herramientas que ya me hacen 00:40:27
Cosas potentes y optimizadas 00:40:30
Para poder utilizar 00:40:33
Lo que ya me proponen los demás 00:40:34
Realmente lo único que tengo que hacer es implementar 00:40:36
determinadas interfaces 00:40:38
pillo mi objeto 00:40:40
implemento la interfaz comparable 00:40:41
y ahora ya puedo utilizar todos los métodos 00:40:44
que trabajan sobre eso como comparable 00:40:47
entonces no tengo que volver a implementar 00:40:48
un método para ordenar 00:40:51
mis arrays, sino utilizo 00:40:53
los métodos que ordenan 00:40:54
arrays que me han hecho otros basándose 00:40:56
sobre comparable 00:40:59
dudas? 00:40:59
sigamos 00:41:09
y aquí 00:41:10
me contradí 00:41:13
Hemos dicho que una interfaz 00:41:16
Es una clase abstracta 00:41:20
Que no tiene métodos 00:41:22
Implementados 00:41:24
No es mentira 00:41:26
Yo puedo pillar una interfaz 00:41:27
Implementar un método 00:41:29
¿Vale? 00:41:31
Existe el concepto de método por default 00:41:33
Método por defecto 00:41:36
¿Vale? 00:41:39
Es decir, que si yo tengo una interfaz 00:41:39
Vale, la interfaz, cada uno la implementará como sea 00:41:42
Pero quiero poder proporcionar 00:41:44
proporcionar un método ya implementado para decir mira por defecto esto en la 00:41:46
mayoría de la mayoría de los casos se implementa si te lo doy ya implementado 00:41:57
luego tú eliges si lo quieres sobreescribir si no lo quieres 00:42:03
implementar lo que sea pero yo te doy ya una versión por defecto como es el caso 00:42:06
Aquí, ¿vale? 00:42:12
Aquí he cambiado un poquito 00:42:15
La interfaz de animal 00:42:17
Y le he puesto 00:42:21
La interfaz de animal tiene habla 00:42:22
Habla es abstracto 00:42:24
¿Vale? No pone abstract 00:42:26
Pero hemos dicho que la interfaz 00:42:28
Si no pongo nada es abstracto 00:42:29
Lo tendrás que implementar tú sí o sí 00:42:30
Y por otro lado te doy default void 00:42:33
Corre 00:42:37
Default es otra palabra 00:42:38
Lo es en rojo 00:42:39
Es una palabra reservada 00:42:40
Te estoy diciendo que esto 00:42:43
Es un método de mi interfaz 00:42:45
Pero es un método al que te doy 00:42:47
Una implementación por defecto 00:42:49
Si tú no lo implementas 00:42:50
Me vale igual 00:42:53
Heredarás esta, en un cierto sentido 00:42:54
Cuidado que no estamos en herencia, estamos en implementación 00:42:57
Y por lo tanto, te digo 00:42:59
Mira, si tú 00:43:03
No haces nada con este señor 00:43:04
En automático, él escribirá 00:43:06
El animal corre 00:43:08
Es su implementación por defecto 00:43:09
¿Vale? Entonces, ¿qué puedo hacer? Pues puedo hacer que en perro implementa animal y decirle, oye, mira, implemento habla, pero no hago nada con corre. 00:43:13
Entonces, corre utilizará la implementación por defecto de la interfaz. Es decir, que si un perro corre, me escribirá el animal corre. ¿Vale? La implementación que viene aquí. 00:43:25
Sin embargo, para hacer un ejemplo distinto 00:43:38
Aquí, en gato 00:43:41
Implemento habla 00:43:43
Y vuelvo a sobrescribir 00:43:45
Reimplementar también corre 00:43:48
Donde en vez de utilizar la entrevista en arriba 00:43:50
Escribo que tiene que escribir el gato corre 00:43:53
Por hacer las dos cosas 00:43:56
Resultado 00:44:00
Que cuando yo llamo dog.corre 00:44:01
Me saldrá el animal corre 00:44:05
cuando llamo cat.corre 00:44:08
el gato corre 00:44:10
y aquí la pregunta es obvia 00:44:11
es obvia, tan obvia que 00:44:17
está aquí la respuesta 00:44:29
¿no? es decir, vale 00:44:32
yo tengo las clases abstractas 00:44:35
las clases abstractas pueden implementar métodos 00:44:36
o hacer métodos abstractos, vale, es fenomenal 00:44:39
y luego tengo las interfaces 00:44:41
que pueden hacer métodos abstractos 00:44:42
o puedo implementarlos 00:44:45
entonces, aquí 00:44:46
Algunas pistas de la diferencia 00:44:52
¿Vale? 00:44:56
¿Qué son? 00:44:57
Primero el propósito 00:44:58
Una clase estrata se utiliza para proporcionar 00:44:59
Una estructura básica para una jerarquía de clases 00:45:02
¿Vale? 00:45:05
Cuando yo uso una clase estrata 00:45:06
Estoy construyendo una jerarquía de clases 00:45:07
Estoy en un cierto sentido 00:45:10
Organizando mis clases 00:45:12
Entre ellas 00:45:14
Tengo persona que debajo tiene empleado 00:45:15
Y tiene debajo 00:45:18
De empleado profesor 00:45:20
Debajo de persona también está estudiante 00:45:21
Estoy creando toda una jerarquía de clases 00:45:23
Que se interrelacionan entre ellos 00:45:26
Y alguna de estas puede ser astrata 00:45:27
Mientras que cuando defino una interfaz 00:45:30
No estoy tanto definiendo 00:45:34
Esta jerarquía de clase 00:45:36
Podría ser que alguna clase 00:45:38
Se implemente en la interfaz o no 00:45:39
Independientemente de donde están en esta jerarquía 00:45:41
Sino que estoy haciendo un contrato 00:45:44
Estoy diciendo 00:45:46
Mira, cuando tú vas a implementar 00:45:47
Esta clase 00:45:50
Que implementa 00:45:53
Mi interfaz 00:45:54
Determinada 00:45:56
Te estás pillando el 00:45:57
Deber de implementar 00:46:00
Todos los métodos que te he dado yo 00:46:03
O sea, te estás pillando 00:46:04
El contrato de decir 00:46:06
Vale, cuando yo implemento 00:46:08
Estos métodos que me has dicho tú 00:46:09
Los tienen que estar en la base de la ley 00:46:11
Independientemente de cual sea mi jerarquía 00:46:13
De clases 00:46:16
Son dos propósitos distintos 00:46:17
En uno estoy dando una herramienta para estar seguro que si alguien implementa mi interfaz 00:46:19
Está implementando esos métodos 00:46:28
Es un contrato entre varios desarrolladores, entre varias partes de mi programa 00:46:29
Sin embargo cuando utilizo una clase abstracta la estoy utilizando para hacer un diseño de cómo es mi estructura 00:46:34
De la estructura de mi sistema 00:46:41
Y a eso da una pizca de diferencia 00:46:44
Segunda implementación de métodos 00:46:47
Bueno, esto es reactivo 00:46:50
Una clase abstracta normalmente 00:46:52
Tiene una parte concreta 00:46:54
Y una parte abstracta, ¿vale? 00:46:56
Algunos métodos concretos y algunos métodos abstractos 00:46:57
Mientras que la interfaz 00:47:00
Por lo general tiene solo abstractos 00:47:01
¿Vale? Y aquí añade a colete 00:47:04
Ella, a menos que no se utilice 00:47:06
Un método default 00:47:08
¿Vale? Que es lo que hemos visto ahora 00:47:09
Y la razón de por qué no se ha movido la técnica 00:47:11
Dos razones más 00:47:13
Herencia, y este es fuerte 00:47:15
¿Cuántas clases puede heredar? 00:47:17
Una 00:47:20
¿Cuántas interfaces puede implementar? 00:47:21
Infinitas 00:47:23
Pues ya tenéis la diferencia suficiente 00:47:23
Para las dos cosas 00:47:26
¿Vale? 00:47:27
Si tengo una clase de strata 00:47:28
Puede heredar solo de esa clase de strata 00:47:29
Y si necesito algunas cosas más 00:47:31
Pues tiro de interfaz 00:47:34
¿Vale? 00:47:36
Entonces, ¿por qué no anulamos la clase de strata 00:47:38
Y la destruimos la clase de strata? 00:47:40
Bueno, en realidad, en mi experiencia 00:47:42
La clase de strata se usa menos 00:47:44
Pero es este punto de aquí 00:47:45
La clase abstracta 00:47:48
Me crea esta organización 00:47:50
Que la interfaz no me crea 00:47:52
Y... 00:47:54
Entonces, herencia múltiple en un lado 00:47:59
Y símbolo en otro 00:48:01
Y también hay una cosa sobre las variables 00:48:02
Esto es también interesante 00:48:05
Las variables en una clase abstracta 00:48:06
Pueden ser estáticas o no estáticas 00:48:09
O sea, yo en una clase abstracta 00:48:11
Puedo crear variables del objeto 00:48:13
Sin embargo, en una interfaz 00:48:16
No puedo crear variables de un objeto 00:48:19
¿Vale? 00:48:22
Porque no la he dado 00:48:24
Implemento 00:48:25
Entonces, una interfaz sí puede tener variables estáticas 00:48:27
Que se referen a esa interfaz 00:48:30
En la que daré la misma forma 00:48:33
Pero no pueden tener variables no estáticas 00:48:35
Entonces, si yo quiero hacer 00:48:38
Algo parecido a esto que estamos viendo ahora 00:48:40
¿Vale? 00:48:43
En general y necesito 00:48:44
En mi jerarquía 00:48:46
Utilizar una clase 00:48:47
Que tenga variables no estáticas 00:48:49
Y de allí extender 00:48:52
Parte de esa que parte 00:48:54
Ostrata y parte no 00:48:55
Pues no puedo hacerlo con una interfaz 00:48:57
Necesito la clase 00:48:59
Ostrata 00:49:02
Y esto es un punto que me dice 00:49:03
Vale, a este punto pues 00:49:05
No puedo destruir 00:49:07
La clase ostrata y decir algo todo con una interfaz 00:49:10
Hay casos particulares en los que necesito todavía el concepto de concepto 00:49:12
Y esto si lo pensáis un poco, habéis sentido un poco el concepto de instancias, etc, etc, etc 00:49:17
¿Entendéis por qué? 00:49:22
La interfaz no es una clase 00:49:23
¿Vale? 00:49:25
La interfaz no genera instancias 00:49:27
¿Vale? 00:49:29
Puede generar referencias 00:49:30
Pero nunca de un new comparable 00:49:32
¿Vale? 00:49:34
Siempre hay una letra pequeña 00:49:40
Es que esto de la programación 00:49:41
es un mundo 00:49:44
y luego está la cosa 00:49:46
más compleja de este curso 00:49:49
hasta ahora 00:49:50
la interfaz funcional 00:49:51
¿qué es? 00:49:53
momento de falta de 00:49:58
respiración 00:50:00
y de broad your mind 00:50:01
porque 00:50:03
llegamos a una cosa que no hemos visto hasta ahora 00:50:06
y que veremos aquí en un momento 00:50:08
pero no estará muy por la noche 00:50:10
te expectaré diciendo 00:50:12
la interfaz funcional 00:50:14
Imaginaos una interfaz 00:50:15
Donde yo pongo esta anotación de aquí 00:50:20
Que es lo que me crea 00:50:22
Una interfaz funcional 00:50:24
Y luego digo 00:50:25
Vale, muy bien 00:50:28
Tengo la interfaz 00:50:29
Esta es declaración 00:50:33
Como class 00:50:34
Operación 00:50:35
Este es el nombre de la interfaz 00:50:37
¿Qué tiene dentro? 00:50:40
Tiene un método 00:50:41
El método ejecutar 00:50:43
Que recibe un A y un B 00:50:45
Vamos a ver cómo se usa esta cosa 00:50:47
Mira adelante 00:50:55
Creo un objeto operación 00:50:56
Y en vez de definir aquí 00:51:00
Su ño o no sé qué 00:51:04
Lo que le estoy pasando 00:51:06
Cómo se hace esta operación 00:51:10
No le estoy pasando un valor 00:51:12
Le estoy pasando 00:51:16
Una función 00:51:18
No estoy almacenando 00:51:19
En una variable 00:51:23
El valor 3 00:51:24
Más estoy almacenando en una variable 00:51:25
Un procedimiento 00:51:28
Que me dice 00:51:30
Dame a y b 00:51:33
Y el resultado es a más b 00:51:33
Y esta es la operación suma 00:51:36
Cuando llamaré suma.ejecutar 00:51:38
De a, b 00:51:42
¿Os acordáis de esto? 00:51:43
¿Qué me hará? 00:51:46
Si yo hago suma.ejecutar de 3,5 00:51:47
¿Qué me hace? 00:51:54
Aplica esta operación, hace 3 más 5 y el resultado es 8 00:51:58
Pero puedo crear una operación multiplicación 00:52:02
Donde le paso como parámetro, como valor 00:52:07
Otra distinta operación 00:52:12
Que es dame A y B 00:52:14
Y el resultado es A por B 00:52:16
Entonces ahora 00:52:18
He usado la misma 00:52:22
Objeto 00:52:23
Pero no le estoy pasando un valor 00:52:26
Le estoy pasando una función 00:52:28
Y esto 00:52:30
Todo esto es basado 00:52:32
Sobre un concepto teórico 00:52:40
Que es el lambda cálculo 00:52:42
Que se da en quinto de 00:52:44
Carrera 00:52:50
¿Vale? 00:52:52
Para poder 00:52:56
para poder especificar todas estas cosas 00:52:57
este señor de aquí 00:53:01
el let in y cosas por el estilo 00:53:02
pues hay todo un lenguaje entre comillas 00:53:04
que es el lambda cálculo 00:53:06
que me permitiría 00:53:08
aquí hacer cosas 00:53:12
muy potentes 00:53:14
¿os acordáis al principio de curso? 00:53:15
porque seguramente estáis repasando 00:53:18
cada 15 días 00:53:20
cuando hicimos una clasificación de los lenguajes 00:53:21
y vimos que había lenguajes 00:53:24
Y había lenguajes funcionales 00:53:26
Cuya característica era que podía pasar como parámetros 00:53:30
Y como variables a funciones en vez de valores 00:53:35
Pues este es el intento que ha hecho Java 00:53:40
Para incluir dentro de Java mismo algo de lenguaje funcional 00:53:45
En realidad tiene sus matices 00:53:50
¿Vale? Porque para que sea funcional de verdad 00:53:58
Debería ser implementado de otra forma 00:54:00
Y cosas por el estilo 00:54:02
Pero lo que está intentando hacer aquí 00:54:03
Es acercarse a lo que son los lenguajes funcionales 00:54:05
¿Y esto por qué? 00:54:08
Porque hay problemas 00:54:11
Que los lenguajes orientados a objetos 00:54:12
Y lenguajes interactivos 00:54:14
Normales que conocemos nosotros 00:54:16
Se permiten solucionar 00:54:18
Súper fácilmente 00:54:20
O sea que hay cosas que 00:54:21
Funcionan muy bien 00:54:23
Los lenguajes orientados a objetos para eso 00:54:25
Y hay otros temas que los lenguajes, sobre todo la programación nuestra, no funcional, no lógica 00:54:27
Que utilizamos nosotros, crea programas súper complejos y súper lentos para poder hacer decenas de cosas 00:54:35
Hay campos en los que esta forma de programar, la que estamos aprendiendo nosotros, no funciona 00:54:44
Es muy engorrosa 00:54:52
Uno de ellos, por ejemplo, es el lenguaje natural 00:54:54
El procesamiento del lenguaje natural 00:54:58
Lo puedes hacer tranquilamente en Java 00:55:01
Pero la forma con que lo logras 00:55:03
Utilizando Prolog 00:55:07
O otros lenguajes de programación lógica 00:55:08
O de programación funcional 00:55:11
Pues es otro mundo 00:55:12
Yo esto lo he vivido 00:55:14
En un curso aquí en la Politécnica 00:55:16
Donde había el procesamiento del lenguaje natural 00:55:22
Había que hacer 00:55:24
No sé, no me acuerdo ni siquiera qué 00:55:25
Me acuerdo que yo me pasé tres días 00:55:27
Lo hacíamos en pareja 00:55:29
Entonces yo me pasé tres días 00:55:31
Haciendo mi programito en Java 00:55:33
Para hacer lo que sea 00:55:34
Y vino mi compañero y le digo 00:55:35
Mira, yo conozco Prolog 00:55:36
Mira, tres líneas de código 00:55:38
Entonces, todo depende 00:55:40
Pero la idea es que 00:55:47
Si en un día futuro 00:55:49
Como el MOOC 00:55:50
¿Vale? Llega un momento en que vosotros veáis runas arcanas en un programa de Java, ¿vale? 00:55:52
Podráis decir, me acuerdo ese tío que hablaba mal, que habló de programación funcional o de interfaz funcional. 00:56:01
Y allí tendréis como un... 00:56:09
Una revelación. 00:56:15
No, no, una sensación mala de esta, de como que hay alguien detrás que intentarlo. 00:56:16
y son cosas complejas 00:56:22
que no se pueden 00:56:26
parar, aprender 00:56:29
esto os lo digo 00:56:30
de verdad, lo pongo aquí 00:56:33
simplemente para que tengáis un 00:56:34
ejemplo, lo podéis copiar 00:56:36
por algún lado y ver que funciona 00:56:38
y cosas por el estilo, pero que 00:56:40
no va a entrar en el examen 00:56:42
ni siquiera para el bien 00:56:44
son cosas que no vamos a 00:56:47
trabajar 00:56:49
esto sería un main 00:56:49
Y este de aquí sería 00:56:57
Y ya está 00:56:59
Autor/es:
stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
16
Fecha:
31 de enero de 2023 - 13:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
57′ 12″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
478.47 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid