Saltar navegación

240219 Interfaces2 - 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

Vale, entonces, vamos a grabar este ejemplo por si luego sirve de algo 00:00:01
Entonces, vamos a hacer un ejemplo de una interfaz, ¿vale? 00:00:06
Vamos a utilizarla, a ver que sale y como que podemos hacer y cosas por el estilo 00:00:10
He buscado ejemplos que no se han hecho por lo mismo, pero me se han hecho por lo mismo si no tengo fantasía 00:00:15
Por lo tanto vamos por vehículo, ¿eh? Lo de siempre 00:00:20
Entonces, la primera cosa es que si creo crear una interfaz 00:00:22
En vez de crear una clase, puedo crear una interfaz 00:00:28
¿Vale? 00:00:33
Misma cosa 00:00:35
Esto de aquí he creado es 00:00:35
New interface 00:00:39
El nombre de la interfaz 00:00:42
¿Vale? 00:00:45
Y nosotros creamos la interfaz 00:00:46
El ejemplo que hemos hecho antes 00:00:50
Así tenemos una referencia 00:00:52
Puede moverse 00:00:53
Para mí, creo que esta interfaz puede moverse 00:00:55
La interfaz puede moverse 00:01:02
Representa el concepto de algo que puede moverse 00:01:04
En el momento en que alguien o algo o una clase puede moverse 00:01:10
Tendrá que implementar un conjunto de métodos 00:01:15
Que voy a definir aquí 00:01:21
¿Sí? 00:01:23
Fijaos, aquí yo no los voy a implementar 00:01:25
Voy simplemente a decir 00:01:28
Que oye, mira, cualquier 00:01:30
Cosa 00:01:31
Que pueda moverse 00:01:34
Pues tiene que implementar estos métodos de aquí 00:01:36
¿Vale? 00:01:38
Por ejemplo 00:01:39
Public int 00:01:41
Desplazarse 00:01:45
Fijaos que no lo implemento 00:01:47
¿Vale? 00:01:58
Y estoy diciendo 00:01:58
Eh mira, tiene que haber este aquí 00:01:59
Podría ponerle un comentario para saber que es esto 00:02:01
¿Vale? 00:02:03
Se mueve 00:02:07
E indica 00:02:09
Cuántos metros 00:02:11
Se ha desplazado 00:02:13
¿Qué más 00:02:17
Puede hacer algo que se puede mover? 00:02:22
Sí, pero aquí no estamos modelizando 00:02:31
Un objeto, estamos modelizando comportamiento 00:02:33
¿Qué mecanismos 00:02:35
¿Qué queremos 00:02:37
Que él pueda hacer? 00:02:39
Él podrá desplazarse 00:02:40
Un objeto puede moverse, no sé, puede parar 00:02:42
Si se puede moverse, puede parar también 00:02:44
No lo sé, ¿eh? Luego... 00:02:46
Uy, voy. 00:02:49
Parar. 00:02:50
Me lo invento. 00:02:51
Como no tengo exactamente... 00:02:53
No sé qué quiero hacer con esto, pues tampoco tengo... 00:02:55
Mucha idea. 00:02:58
Esto es... 00:03:00
Puede moverse... 00:03:03
Pero no lo hace. 00:03:06
Otra cosa le queremos poner. 00:03:12
Aquí yo estoy definiendo un contrato con todos los que implementen esta interfaz 00:03:16
Diciendo si quieres implementar mi interfaz tendrás que implementar este método y este método aquí 00:03:27
Sea lo que sea lo que tienen que hacer 00:03:35
Está claro que la interfaz debería definir de forma clara que hace cada uno de estos métodos 00:03:37
Luego la implementación con que lo haces 00:03:46
Es tu responsabilidad 00:03:48
Pero yo te digo que hace 00:03:50
O sea, si desplazarse 00:03:51
Luego resulta que otro lo implementa 00:03:53
Con que escribe en pantalla 00:03:56
Miau 00:03:58
Pues has implementado el método, sí 00:03:58
Pero no lo has implementado correctamente 00:04:01
Con respecto a las especificaciones que te he dado 00:04:04
Si yo os divido 00:04:06
Este grupo de aquí 00:04:08
Implementa un objeto 00:04:09
Crea un objeto que implementa esta interfaz 00:04:11
Y este grupo de aquí lo usa 00:04:14
Y resulta que luego este de aquí 00:04:15
Están hablando de un coche 00:04:17
Y le llaman desplazarse para ver que se mueva 00:04:18
Y vosotros habéis implementado que dice miau 00:04:21
Pues luego el programa no funciona 00:04:23
¿Me explico? 00:04:25
¿Si? 00:04:29
Vale 00:04:30
Dejamoslo así 00:04:30
Para hacerlo sencillo 00:04:33
Entonces estos son los dos medios 00:04:34
Vale, fenomenal, mi interfaz sigue ahí 00:04:36
Ahora lo que puedo ir a hacer 00:04:39
Es crearme una clase 00:04:41
Y crearé la clase 00:04:44
Vehículo 00:04:46
Esta clase vehículo 00:04:48
Puede tener lo que le da la gana 00:04:54
Int, matricula 00:04:56
Que es un identificador 00:04:59
Luego puede tener 00:05:01
Que se yo 00:05:04
String, color 00:05:05
Puede tener 00:05:07
un método 00:05:10
que es public void 00:05:15
de escribir 00:05:20
que dice 00:05:21
soy un vehículo 00:05:24
vehículo 00:05:31
de color 00:05:32
más color 00:05:35
Si, este es un método 00:05:37
Propio de esta clase 00:05:41
Y ahora yo le podría decir, si pero es claro que el vehículo 00:05:42
Sea un 00:05:45
Algo que pueda moverse 00:05:47
¿Cómo lo hago? Pues como antes aquí 00:05:49
Extendía otra clase 00:05:51
Ahora hago implement 00:05:53
Puede moverse 00:05:55
Y el se enfada 00:05:58
Dice, oye mira 00:06:00
Si has dicho que implement 00:06:01
Puede moverse 00:06:03
Error 00:06:04
Tiene que implementar 00:06:05
Los métodos 00:06:09
Astratos desde 00:06:10
Puede moverse, punto, parare 00:06:12
Vale, o sea, faltan 00:06:14
Algunos métodos 00:06:16
Vale, entonces yo le puedo decir 00:06:18
Mira, si ponmelo aquí debajo 00:06:20
Entonces aquí 00:06:22
Me han aparecido 00:06:26
Los dos 00:06:28
Métodos que tengo que hacer, vale 00:06:30
Claramente de una forma mock 00:06:32
En un cierto sentido, de la forma que 00:06:34
¿A qué hacen? Nada, ¿vale? 00:06:35
Entonces 00:06:38
En la interfaz se están mentirando, ¿no? 00:06:39
Para que sean obligatorios ya 00:06:42
Claro, esto 00:06:43
Lo que me está diciendo es que 00:06:45
Quien quiera implementar esta interfaz 00:06:47
Tendrá necesariamente 00:06:50
Que poner estos dos 00:06:52
Y entonces si yo a mi vehículo 00:06:53
Aquí le puedo decir, pues 00:06:57
Interdesplazarse, cuando 00:06:59
Este se desplaza, escribe 00:07:00
Chiso 00:07:03
Me estoy moviendo 00:07:05
Moviendo 00:07:08
Y luego devuelve 00:07:10
100 metros 00:07:12
Que es cuanto se mueve 00:07:14
¿Vale? 00:07:16
Y separar 00:07:17
Dice 00:07:18
Chiso 00:07:19
Me paro 00:07:20
Ya está 00:07:23
Los ha implementado 00:07:25
Ahora 00:07:29
Es un ejemplo sencillo 00:07:29
¿Vale? 00:07:32
Un ejemplo más complejo 00:07:33
Pues esto debería ser un proyecto más complejo 00:07:34
Voy 00:07:36
A probarlo 00:07:37
Me creo una clase 00:07:40
Prueba 00:07:42
Con un main 00:07:46
Y ahora voy a crear cosas 00:07:49
Por ejemplo, puedo crear un vehículo 00:07:53
Vehículo v1 00:07:55
Es igual a new vehículo 00:07:57
Y ahora puedo hacer que v1.describir 00:07:59
Se puede describir 00:08:07
v1.desplazarse 00:08:09
v1.parar 00:08:14
Se define 00:08:29
Color en null 00:08:31
Porque no he hecho un constructor 00:08:32
Que me dijera cuál es el color 00:08:34
Por lo tanto el color en null 00:08:36
Me estoy moviendo 00:08:37
¿Vale? 00:08:39
Fenomenal 00:08:42
Aquí podría poner 00:08:42
Int 00:08:45
Metros 00:08:46
Que son todos los metros 00:08:52
Que ha hecho este vehículo 00:08:55
Y cada vez que lanza a desplazarse 00:08:56
Pues además de revolver a 100 00:08:59
Lo que hace es 00:09:01
Metros es igual 00:09:03
Paso igual 00:09:05
100 00:09:06
Y cuando se describe 00:09:07
Y es recorrido 00:09:11
Más metros 00:09:16
Entonces ahora cuando lanzo esto 00:09:20
Que ha recorrido cero 00:09:29
Si llego al final 00:09:30
En prueba 00:09:32
Y lo hago describir otra vez 00:09:35
Ahora ha recorrido 00:09:38
¿Si? 00:09:44
Estamos hasta aquí todos 00:09:46
Vale 00:09:48
¿Qué más puede hacer? 00:09:49
Pues 00:09:53
Este es vehículo 00:09:53
En vez de crearme 00:09:56
Un objeto vehículo 00:09:59
Lo que podría intentar hacer 00:10:00
Es crearme un objeto 00:10:02
Puede moverse 00:10:04
Puedo hacer esto 00:10:05
Porque 00:10:24
Un interfaz 00:10:24
No se puede instanciar 00:10:26
¿Vale? Una clase se puede instanciar 00:10:28
Una interfaz, no, no puedo crear 00:10:30
Un nuevo objeto 00:10:32
Pero si que lo que puedo hacer 00:10:33
Es crear, es meter aquí 00:10:36
En un objeto de tipo puede moverse 00:10:38
Un cualquier 00:10:40
Una cualquiera clase 00:10:42
Que implemente eso 00:10:43
¿Si? Vale 00:10:46
Ahora puedo hacer 00:10:52
Y fijaos que solo me aparece 00:10:54
Desplazarse, parar 00:10:59
Y los ordenados de object 00:11:03
Es decir, que ya no puede hacer 00:11:05
Por ejemplo, describir o acceder a metros 00:11:07
O cosas por el estilo 00:11:09
Porque ahora mismo 00:11:10
PM1 es un objeto 00:11:12
Puede moverse 00:11:15
De tipo 00:11:16
Solo puede desplazarse o parar 00:11:18
Esto yo lo puedo hacer 00:11:21
Si lo lanzo 00:11:22
Esto funciona 00:11:33
Me está moviendo, me paro 00:11:35
¿Vale? ¿Qué pasa? 00:11:38
Pero 00:11:39
Que 00:11:39
Las cosas propias de vehículos 00:11:41
Están escondidas por debajo 00:11:45
¿Vale? Porque mi referencia 00:11:47
Es de este tipo 00:11:49
Yo no puedo hacer 00:11:50
PM1.describir 00:11:51
Porque 00:11:54
El tipo puede moverse 00:11:59
No tiene describir 00:12:01
¿Están de acuerdo con esto? 00:12:03
Yo estoy utilizando este aquí 00:12:07
Ahora, cuidado también 00:12:09
Cuando yo llamo desplazarse 00:12:10
No estoy llamando 00:12:14
Este desplazarse 00:12:17
Porque este desplazarse 00:12:19
No tiene implementación 00:12:20
Por polimorfismo 00:12:22
Este desplazarse 00:12:26
Se ha sobrescrito dentro del vehículo 00:12:29
De aquí 00:12:33
Y entonces cuando él va a elegir 00:12:33
Si va a utilizar esto o este método 00:12:37
Lo que va a hacer es mirar la instancia 00:12:40
Y la instancia es un vehículo 00:12:43
No es un puede moverse 00:12:45
Y por lo tanto va a usar 00:12:47
El desplazarse 00:12:49
Más específico de la instancia 00:12:50
Es decir esto 00:12:53
¿Ludas? 00:12:54
Vale 00:13:01
Porque yo podría hacer 00:13:01
esforzar que PM1 00:13:17
se vea 00:13:27
como un vehículo 00:13:30
y ahora 00:13:32
veis que puedo acceder 00:13:39
a todas las cosas del vehículo 00:13:42
describir, desplazarse, etc. 00:13:45
Y me funciona 00:13:47
¿Vale? 00:14:00
Teniendo en cuenta que 00:14:04
Esto lo puedo hacer 00:14:05
Si estoy seguro 00:14:08
Que este señor de aquí es un vehículo 00:14:09
Si no, debería haber hecho algo como 00:14:11
Sí 00:14:14
PM1 00:14:15
Instance of 00:14:18
Vehículo 00:14:20
Entonces 00:14:21
Esto 00:14:25
De esta forma sé que voy a llamar 00:14:28
Este de aquí, si, solo si 00:14:33
Efectivamente es un vehículo 00:14:35
Mejor dicho, voy a hacer este casting 00:14:36
De decir, oye 00:14:39
Tráctame esta referencia, que es una referencia 00:14:41
puede moverse como vehículo 00:14:43
si, solo si 00:14:45
efectivamente lo que tengo dentro es una instancia 00:14:47
de vehículo, si no es una instancia de vehículo no lo hago 00:14:49
¿Dudas? 00:14:51
Vale 00:14:56
Pero, imaginémonos que 00:14:56
el vehículo sea muy abstracto 00:14:59
y yo digo, tengo los métodos descritos 00:15:01
pero no sé bien cómo desplazarme 00:15:03
o sea, parar 00:15:05
es fácil, me paro, todos los vehículos 00:15:07
cuando se paran, se paran 00:15:09
¿Vale? Pero eso de moverse es un poco 00:15:10
Más complejo 00:15:13
Dependerá de que tipo de 00:15:15
Vehículo es 00:15:19
¿Vale? 00:15:22
Entonces decido, oye mira, esto no lo quiero implementar 00:15:23
¿Vale? 00:15:27
No lo quiero implementar 00:15:28
¿Qué pasa? 00:15:29
Que si no lo implemento, se enfada 00:15:31
¿Vale? 00:15:33
Entonces podría decir, ah sí 00:15:35
Pero claro, esto se enfada 00:15:37
Porque dice, tienes que devolver algo, o sea 00:15:40
No puedo implementarlo vacío 00:15:41
Poner return cero, ya está, ha implementado 00:15:44
Pero si lo que puedo hacer 00:15:46
Es decir, espera, espera, espera 00:15:48
Este 00:15:49
Es un método abstracto 00:15:54
¿Vale? 00:15:59
Pero no me lo 00:16:00
No me permite hacerlo, ¿por qué no me permite hacerlo? 00:16:01
Me he cargado una paréntesis 00:16:11
Que no me tenía que cargar 00:16:23
Y este abstracto yo aquí 00:16:24
¿Dónde está la paréntesis? 00:16:26
Este abstracto aquí 00:16:32
Ahí 00:16:33
Es más 00:16:37
Ahora ya no se queja 00:16:42
Yo estoy implementando 00:16:47
Una interfaz 00:16:50
Esta interfaz me 00:16:53
Me trae 00:16:54
Todos estos métodos que son 00:16:56
Astratos, aquí no pone astrato 00:16:59
Pero todos los de la interfaz se asumen 00:17:00
Como astrato, yo digo, mira 00:17:03
Te la implemento 00:17:04
Pero yo soy una clase abstracta 00:17:05
Porque uno de estos métodos 00:17:09
En realidad no lo he sobrescrito 00:17:11
Lo he dejado allí 00:17:13
Entonces tengo una clase abstracta 00:17:15
Que implementa una interfaz 00:17:17
¿Si? 00:17:19
Y eso quiere decir que 00:17:22
Esta clase si tiene 00:17:23
Este método de aquí 00:17:25
Pero no lo implementa 00:17:27
¿Quién lo implementará? 00:17:30
Pues alguien que extenderá 00:17:32
Esta clase 00:17:34
Aquí se enfada ahora 00:17:34
Porque claro, ahora vehículo 00:17:40
Ya no me vale 00:17:41
Porque siendo una clase astrata 00:17:43
No puedo crear un vehículo 00:17:46
Volveré aquí 00:17:47
Me creo 00:17:52
Otra clase 00:17:53
Esta clase aquí 00:17:55
Es la clase 00:17:59
¿Cómo no? 00:18:02
Coche 00:18:04
Y la clase coche 00:18:04
Extends 00:18:08
Vehículo 00:18:10
Ahora me está diciendo que a la clase coche 00:18:11
Le faltan cosas 00:18:18
¿Cuál le falta? Desplazarse 00:18:19
¿Por qué no le falta tampoco 00:18:21
Pararse? Porque pararse está aquí 00:18:23
Parar 00:18:26
Existe 00:18:27
Ya ha sido implementado a este nivel 00:18:29
A nivel de vehículo 00:18:31
Todos los vehículos se paran igual 00:18:32
Pero lo que hacía falta 00:18:33
Era implementar este de aquí 00:18:38
Que viene desde 00:18:40
La interfaz 00:18:42
¿Vale? 00:18:43
El vehículo implementa esa interfaz 00:18:44
Pero aquí lo deja como abstracto 00:18:47
Y por lo tanto 00:18:49
Ahora este queda para implementarse 00:18:51
Y es aquí donde digo 00:18:53
Si, soy un cocho 00:18:55
Como ROM 00:18:58
Retorno a 100 00:19:03
Puedo aquí 00:19:09
Sumar 00:19:13
Que me he movido 100 metros 00:19:15
Puedo acceder a metros 00:19:17
Tranquilamente. 00:19:28
¿Por qué? 00:19:29
Porque lo estoy heredando desde aquí. 00:19:30
Vale. 00:19:35
Pues me creo otro vehículo. 00:19:41
Clase. 00:19:46
Y aquí creo avión. 00:19:48
Avión. 00:19:53
Extends. 00:19:54
Vehículo. 00:19:56
Entonces aquí me dice 00:19:58
Mismo problema 00:20:01
Añado la implementación 00:20:02
Pero, claro, esto dice 00:20:04
Si, so 00:20:07
Soy un avión 00:20:08
Los acentos 00:20:11
Para evitar carácter raros 00:20:13
Y metros 00:20:16
Más, igual, mil 00:20:18
Claro, más rápido 00:20:20
Va más lejos 00:20:23
se entiende 00:20:30
estas son implementaciones distintas 00:20:32
ahora en este caso son parecidas 00:20:35
porque es el ejemplo que es 00:20:37
pero uno podría hacer de una forma 00:20:38
uno completamente de otro 00:20:40
se dice rom voy volando 00:20:42
voy volando 00:20:44
están haciendo 00:20:47
una implementación completamente distinta 00:20:49
del mismo método que es el método de desplazarse 00:20:51
los dos al final 00:20:53
Al cabo son objetos 00:20:55
Que pueden moverse y lo que pueden hacer es 00:20:57
Llamar desplazarse para desplazarse 00:20:59
Pero como lo hacen 00:21:01
Puede ser completamente distinto 00:21:02
Son códigos completamente distintos 00:21:04
Si yo quisiera por ejemplo 00:21:06
En el caso de coches 00:21:09
Yo quisiera poner 00:21:12
No sé, todo terreno 00:21:13
Y fórmula 1 00:21:16
Cada uno correrá de distinta forma 00:21:17
Entonces para poderle poner 00:21:20
Tendría que ponerlo otra vez 00:21:22
Puedes ponerlos a través de astrato 00:21:24
O puedes no ponerlos a astrato 00:21:29
Y hacer que un coche vaya de una forma 00:21:30
Y el todoterreno vaya de otra 00:21:32
Siempre con el concepto de sobrescriptura 00:21:33
Ahora hacemos algo parecido 00:21:36
¿Vale? 00:21:37
Y ahora tengo aviones y coches 00:21:39
¿Vale? 00:21:41
Vamos a 00:21:44
Crear otra clase 00:21:45
Y hacemos la clase 00:21:49
Coche 00:21:51
Carrera 00:21:55
Coche de carrera 00:22:01
Extende 00:22:04
Coche 00:22:05
Vale, fijaos que 00:22:08
Ahora tenemos varias 00:22:11
Casuísticas 00:22:13
Casos distintos, vale 00:22:15
Tenemos una clase 00:22:17
Astrata con un 00:22:19
objeto que hereda de la clase 00:22:21
astrata y luego otra clase 00:22:23
que hereda de una clase concreta 00:22:26
vale 00:22:27
aquí si os fijáis no me dice que 00:22:28
falta nada, esta es una clase ya 00:22:31
que puede ir, vale, y aquí podría 00:22:33
poner string 00:22:37
se dice escudería en español 00:22:39
escudería 00:22:42
y aquí sus 00:22:44
constructores o lo que le da la gana 00:22:47
vale, y puedo aquí 00:22:49
Si quiero 00:22:51
¿Cómo se dice? 00:22:52
Sobrescribir los métodos que yo quiera 00:22:56
¿Vale? 00:22:59
Tanto de coche 00:23:00
Como de vehículo 00:23:01
Como de poder moverse 00:23:03
¿Vale? 00:23:05
Todo llega allí heredado 00:23:06
Por ejemplo, lo más obvio 00:23:07
Es que haga algo distinto 00:23:09
Aquí, ¿vale? 00:23:11
Entonces, pillo 00:23:13
Pillo esto 00:23:14
Sobrescribo esto 00:23:18
El coche 00:23:21
De carrera 00:23:22
Super duro 00:23:24
¿Vale? 00:23:28
Y este, claro, es más rápido 00:23:31
No como un avión, pero casi 00:23:33
¿Si? 00:23:35
Y también podría decir 00:23:41
Voy a 00:23:43
Sobrescribir, por ejemplo 00:23:45
La descripción de vehículo 00:23:47
Y un coche carrera 00:23:51
Dice soy un 00:23:56
Coche 00:23:57
De carrera 00:23:59
De color 00:24:02
No se que no se cuanto 00:24:04
De la escuderia 00:24:08
Y escuderia 00:24:10
Vale 00:24:19
Entonces su descripción ha cambiado 00:24:19
¿Está de acuerdo más o menos lo que tenemos? 00:24:22
Vamos a probarlos 00:24:28
A ver que pasa 00:24:29
Estoy con la prueba, ¿vale? 00:24:31
Estos de aquí 00:24:33
Ya no los puedo usar 00:24:34
Porque no puedo crear 00:24:37
No puedo crear vehículos 00:24:38
¿Pero qué puedo hacer? 00:24:40
Pues, puedo crearme 00:24:46
Bueno, cada objeto se puede crear con su propia referencia 00:24:48
Nosotros nos interesa utilizar un poco de polimorfismo 00:24:51
¿Vale? 00:24:53
Entonces vamos a crear un vehículo 00:24:54
Que es, por ejemplo, un coche 00:24:56
Otro vehículo 00:25:04
Vamos a ver, que es un avión 00:25:18
Y otro vehículo 00:25:21
Que es un coche de carrera 00:25:28
¿Sí? 00:25:42
Vale, ¿y ahora qué puedo hacer con estas cosas aquí? 00:25:45
Vamos a ver 00:25:48
Un bucoche 00:25:49
Punto 00:25:51
Estas son las cosas que puede hacer 00:25:53
Con un coche 00:25:56
Que fijaos, son las cosas que puede hacer con un vehículo 00:25:58
¿Sí? 00:26:01
Me puede escribir 00:26:05
Desplazarse, cosas por el estilo 00:26:06
Llamamos desplazarse sobre todo 00:26:08
Y también 00:26:10
Va avión 00:26:13
Pues puede hacer las mismas cosas 00:26:15
Y lo mismo 00:26:19
El coche de carrera 00:26:30
¿Sí? 00:26:39
Pueden hacer lo que hace vehículo 00:26:42
Porque estas son todas referencias de vehículo 00:26:44
¿Vale? 00:26:46
Lanzo 00:26:47
Soy un coche 00:26:48
Soy un avión, voy volando 00:26:51
Soy un coche de carrera, super room 00:26:52
Cada uno de ellos tiene su propio 00:26:54
Desplazarse 00:26:57
¿Si? 00:26:59
Porque coche tiene su desplazarse 00:27:01
Avión tiene su desplazarse 00:27:04
Coche de carrera tiene su desplazarse 00:27:07
Fijaos que yo los he llamado 00:27:09
Todos como vehículos 00:27:11
Pero Java automáticamente ha ido a buscar el desplazarse más específico de cada uno de estos objetos 00:27:13
En base a la instancia que son 00:27:20
¿Sí? 00:27:22
Prueba 00:27:29
Moverse 00:27:30
No puede 00:27:33
Puede moverse 00:27:36
Esto también lo puedo hacer 00:27:39
¿Sí? 00:27:47
Misma cosa 00:27:53
¿Por qué lo puedo hacer? 00:27:54
Porque yo puedo decir que cualquier objeto que implemente la interfaz puede moverse 00:27:55
Puedo utilizarlo con referencia puede moverse 00:28:03
¿Sí? 00:28:07
Fijaos, pero, que si yo voy a mirar 00:28:08
Por ejemplo, bucoche 00:28:11
Aquí, por ejemplo, la descripción no la puedo llamar 00:28:13
Porque dentro de puede moverse, no hay descripción 00:28:19
Hay solo desplazarse o parar 00:28:24
¿De acuerdo con esto? 00:28:27
Vale 00:28:33
Vamos ahora a ver otra cosa 00:28:34
Vamos a meternos otra vez 00:28:37
Como vehículos 00:28:41
Espérate, coche carrera 00:28:46
Describir 00:28:49
Vamos a meter 00:28:51
Que este es 00:28:54
Esto es un 00:28:56
¿Cómo se llama esto? Un vehículo 00:29:02
Y este también es un vehículo 00:29:04
Y en vez de desplazarse 00:29:09
Le pongo describir 00:29:12
¿Vale? 00:29:13
Fijaos 00:29:24
Que el coche 00:29:25
Está diciendo que soy un vehículo 00:29:27
De color no sé qué, no sé cuánto 00:29:30
Mientras que el coche de carrera 00:29:32
Dice, soy un coche de carrera 00:29:34
De color no sé qué, no sé cuánto 00:29:36
Escudería no sé qué, no sé cuánto 00:29:37
Fijaos que 00:29:39
Lo que quiero decir 00:29:41
Es que coche 00:29:44
No sobreescribe la descripción 00:29:45
Entonces 00:29:48
Yo estoy siempre utilizando 00:29:49
Una forma de polimorfismo 00:29:53
Pero 00:29:55
No obstante yo sea un coche 00:29:57
La versión 00:30:00
más específica 00:30:03
del método 00:30:05
de escribir, no es la 00:30:07
de coche, porque aquí no está 00:30:09
de escribir, no ha sido sobrescrita 00:30:11
y por lo tanto estoy usando 00:30:13
la de mi padre 00:30:15
por eso digo que soy un vehículo 00:30:16
ahora, en vez de coche de carrera 00:30:18
que sobrescribe, fijaos que ha saltado 00:30:27
una generación, el abuelo 00:30:29
tiene de escribir, el padre no 00:30:31
lo tiene y el hijo vuelve a 00:30:33
sobreescribir de escribir 00:30:35
pues entonces cuando se va a llamar 00:30:36
de escribir sobre un coche de carrera 00:30:39
se va a utilizar el más específico 00:30:41
de esa instancia, o sea el que está definido 00:30:43
en coche de carrera, esto 00:30:45
se entiende 00:30:47
más o menos por donde van los tiros 00:30:49
y ahora 00:30:51
me voy a hacer 00:30:55
una nueva clase, que es la clase Persona. Aquí. Y, increíblemente, la clase Persona 00:31:01
puede moverse. O es que solo los coches y los vehículos se pueden mover. Entonces, 00:31:14
Si yo quiero que persona pueda moverse 00:31:26
Necesita desplazarse 00:31:28
Y parar 00:31:31
Estoy parado 00:31:31
Y aquí dice 00:31:37
Ando un poquito 00:31:45
Vale 00:31:46
ahora qué pasa 00:31:56
que nosotros antes en nuestra prueba 00:31:59
yo podía utilizar aquí o vehículo puede moverse y cambiaba poco o nada 00:32:04
porque menos mal vehículo era como 00:32:12
la la la 00:32:15
la parte más alta de esta jerarquía de que 00:32:20
Un vehículo, un coche es un vehículo, un coche carrera es un coche que es un coche vehículo, un avión es un vehículo, etcétera, etcétera, etcétera. 00:32:23
Me cambiaban las cosas que podía hacer, ¿os acordáis? Que si hago vavión punto, me salen algunos métodos menos, porque me sale solo desplazar y parar. 00:32:30
Si en vez lo uso su coche, por ejemplo 00:32:45
Me aparecen también las cosas 00:32:48
Además de desplazarse y de parar 00:32:51
Que son las cosas que he heredado 00:32:54
Pues me aparecen también las cosas que son propias del vehículo 00:32:56
¿Sí? 00:33:00
Lo que pone ahí de object 00:33:01
Lo que explicaste es que da... 00:33:05
Esto 00:33:08
Donde pone vehículo, vehículo 00:33:10
puede moverse en otros pone 00:33:13
object, eso sería lo que dijiste 00:33:15
de lo de la herencia 00:33:17
de que todo venía heredado 00:33:20
de object 00:33:22
de aquí se ve algunas cosas que vienen 00:33:22
heredadas de object como por ejemplo 00:33:26
el weight 00:33:28
o el notify all 00:33:30
o el 00:33:31
equals 00:33:32
to string 00:33:34
vale, pero 00:33:36
no, en el sentido de 00:33:39
No sé que estás viendo tú de object 00:33:42
Que deriva de object 00:33:44
Pero aquí no se ve 00:33:46
Los object que ves aquí son 00:33:47
O lo que devuelve o lo que usa como parámetro 00:33:50
De estos métodos 00:33:52
Llegaremos allí, por ahora 00:33:54
Dejamoslo a un lado, vale 00:33:56
Lo que quiero decir con esto es 00:33:57
Vale, muy bien 00:34:00
Y si ahora 00:34:01
Yo quiero hacer 00:34:04
Un array de 00:34:05
Cosas que pueden moverse 00:34:08
Porque además de los vehículos 00:34:10
Quiero poder poner 00:34:12
Objetos 00:34:14
Persona, lo puedo hacer 00:34:16
Por ejemplo 00:34:18
Yo puedo hacer un 00:34:21
Puede moverse 00:34:23
Array 00:34:25
Es igual a new 00:34:28
Puede moverse 00:34:32
Me he creado un array 00:34:38
De cinco 00:34:43
Posiciones 00:34:45
De tipo puede mover 00:34:46
¿Vale? 00:34:48
Entonces, ¿Qué voy a hacer aquí dentro? 00:34:49
Pues, en array 00:34:51
De cero 00:34:53
Puedo poner, por ejemplo 00:34:55
Un nuevo 00:34:58
Coach 00:35:00
En array de uno 00:35:02
Puedo poner un nuevo vehículo 00:35:07
Puedo hacerlo 00:35:13
¿Por qué no? 00:35:14
Porque vehículo es abstracto, no puedo crear un vehículo 00:35:20
Un instante vehículo no lo puedo hacer 00:35:23
Lo que puedo hacer es crearme un vehículo 00:35:26
Que en realidad es un coche carrera, por ejemplo 00:35:30
Y ponerlo tranquilamente allí dentro 00:35:34
Estoy diciendo que en esta red aquí 00:35:36
Que contiene objetos de tipo puede moverse 00:35:44
Te estoy metiendo 00:35:47
VCDC 00:35:48
Que es un vehículo como referencia 00:35:50
Y que dentro tiene 00:35:53
Una red 00:35:55
Una instancia 00:35:56
Coche de carrera 00:35:59
Fijaos que aquí estoy trabajando con tres tipos 00:36:00
La referencia de este array 00:36:03
Es que es un puede moverse 00:36:07
Aquí dentro hay todas las celdas 00:36:09
Contienen un objeto puede moverse 00:36:10
Y yo le estoy metiendo dentro 00:36:13
Un objeto cuyo tipo es vehículo 00:36:15
Que en realidad contiene 00:36:17
Una instancia que es coche de carrera 00:36:19
Tres tipos 00:36:21
Están jugando aquí 00:36:23
Si no entiendo bien que son estos de los tipos 00:36:24
Que es una clase, que la clase define 00:36:27
Un tipo, etc, etc 00:36:29
Pues aquí luego llega un momento en que me lío 00:36:30
porque no sé que estoy haciendo 00:36:32
pero es más 00:36:35
y aquí dentro puedo poner 00:36:36
en array 00:36:39
de 2 00:36:40
creo un new 00:36:43
coche de 00:36:47
carrera directamente 00:36:48
en array 00:36:50
de 3 00:36:53
pongo un new avión 00:36:54
y en array 00:36:57
de 4 00:37:00
Pongo 00:37:01
Mi pecho 00:37:07
Fijaos que 00:37:08
Este array puede moverse 00:37:15
Contiene dentro 00:37:16
Todos los objetos 00:37:19
De tipos distintos 00:37:20
Porque tiene uno, dos, tres, cuatro y cinco 00:37:22
Tipos distintos aquí dentro 00:37:24
Pero todos son 00:37:26
Accomunados por una cosa 00:37:28
Tienen en común una cosa 00:37:29
Todos implementan 00:37:31
No heredan 00:37:48
Implementan la interfaz puede moverse 00:37:49
Todas las clases que estoy usando aquí 00:37:52
Implementan las clases puede moverse 00:37:54
¿Y qué implica esto? 00:37:56
Que yo ahora puedo hacer tranquilamente 00:37:58
un for 00:38:00
puede 00:38:01
moverse 00:38:04
dos puntos 00:38:08
array 00:38:10
y decir que pm 00:38:11
punto 00:38:15
desplazarse 00:38:16
porque 00:38:18
todos los array 00:38:23
todas las cosas que estoy metiendo aquí dentro 00:38:25
independientemente de que sean 00:38:28
coches o lo que sea 00:38:30
¿Te puedo robar dos minutitos? 00:38:31
Déjame un segundo 00:38:34
Vale, perfecto 00:38:35
Todos los 00:38:38
los objetos 00:38:40
que tengo aquí dentro 00:38:42
son de tipo puede moverse 00:38:43
y entonces 00:38:45
puedo llamar los métodos 00:38:47
de puede moverse sobre cualquiera 00:38:49
de estos objetos de aquí 00:38:51
Por polimorfismo 00:38:52
cada uno utilizará el suyo 00:38:55
¿Sí? 00:38:57
Entonces cuando ahora lo lanzo 00:38:59
Que empieza desde 00:39:02
Espera que pongo 00:39:06
A partir de aquí 00:39:10
Hace esta cosa aquí 00:39:19
Si veamos que escribe 00:39:20
Y utiliza 00:39:22
Esto es el desplazarse de coche 00:39:25
Este es el desplazarse de coche de carrera 00:39:27
Otro de coche de carrera 00:39:30
Acordaos que esto lo había guardado como si fuera 00:39:31
La referencia vehículo 00:39:34
Mientras este es directamente un objeto coche de carrera 00:39:36
O soy un avión 00:39:39
O soy una persona 00:39:40
Me da igual que 00:39:41
Hereden de lo mismo o de lo que sea 00:39:44
¿Vale? 00:39:46
Puede ser una cosa que no está en la cadena de herencia 00:39:47
Que yo he creado de vehículo, coche, cosa por el estilo 00:39:50
La persona no es un vehículo 00:39:53
Pero como implementa el puede moverse 00:39:54
También lo puedo meter aquí 00:39:56
¿Sí? 00:39:58
¿Y para qué sirve esto? 00:40:01
Pues 00:40:03
Depende 00:40:03
Pero ya he hecho que 00:40:05
Si hay una acción 00:40:08
Que puedan hacer todos mis objetos 00:40:10
No obstante sean los objetos más heterogéneos 00:40:12
Que queráis 00:40:15
Porque uno es una persona, uno es un vehículo 00:40:16
Uno es un gato, uno es no sé qué 00:40:18
Pero como todo se implementa la misma 00:40:20
¿Cómo se llama? 00:40:22
La misma interfaz 00:40:24
que es como mi contrato 00:40:25
que cualquiera que implemente esta 00:40:28
interfaz tiene que poder hacer esto 00:40:29
pues estos dos métodos lo puedo llamar 00:40:32
sobre todos 00:40:34
los objetos que sean 00:40:35
de tipo puede moverse 00:40:38
lo que es 00:40:39
bastante potente 00:40:41
y otra cosa es, yo en cada momento 00:40:43
puedo intentar acceder 00:40:48
a las cosas específicas 00:40:49
de cada uno de ellos 00:40:52
yo puedo preguntarme 00:40:53
Instance of 00:40:59
Persona 00:41:02
Tiene otro método 00:41:09
Persona 00:41:11
Un método que 00:41:12
Una clase que tenga solo un método 00:41:17
Espectativo, bueno lo hago en persona 00:41:19
Persona puede también 00:41:21
public void saludar 00:41:22
que los demás no tienen 00:41:25
que dice hola 00:41:28
vale 00:41:32
entonces yo lo que puedo hacer aquí es decirme 00:41:32
y además si 00:41:35
la pm 00:41:36
el objeto que estoy mirando ahora de este array 00:41:38
es un instancia 00:41:41
instancia persona 00:41:42
entonces lo que puedes 00:41:44
hacer es un casting 00:41:47
a persona 00:41:49
De este PM 00:41:51
Y llamarme 00:41:53
Saludar 00:41:56
Y entonces 00:42:01
Ahora salud 00:42:03
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
11
Fecha:
19 de febrero de 2024 - 13:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 12″
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:
216.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid