Saltar navegación

Ejercicios Clase Abstractas y Polimorfismo - 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 30 de enero de 2023 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

grabamos esto con sentimientos y habláis vale entonces aquí vamos a hacer algunas pruebas de 00:00:00
clases abstractas entonces me he creado un paquete aquí de figuras vamos a trabajar con figuras 00:00:07
geométricas porque es algo que es bastante natural lo conocéis y tiene bastante sentido en trabajarlo 00:00:14
como clases abstractas vale entonces me voy a crear una nueva clase que sea una clase genérica 00:00:23
Que es una clase abstracta, ¿vale? 00:00:29
Si os fijáis, cuando creo, aquí me da la posibilidad de hacer la abstracta directamente 00:00:31
¿Sí? Lo puede elegir, ¿vale? 00:00:36
Pero por ahora vamos a hacer una clase normal 00:00:39
Y luego vamos a extraerla después, ¿vale? 00:00:41
Entonces, yo creo una clase figura 00:00:45
Esta es una clase normal y corriente 00:00:48
Pues una figura que tiene, ¿vale? 00:00:56
Ya lo hemos hecho 00:00:59
Un int 00:01:00
Lados 00:01:01
¿No? 00:01:02
Que me dice 00:01:04
Cuántos lados 00:01:04
Tiene esta figura 00:01:05
¿Qué más puede hacer? 00:01:06
¿Qué pensáis 00:01:10
Que puede hacer una figura? 00:01:11
Pues 00:01:13
Lo de siempre 00:01:13
¿No? 00:01:14
Calcular su área 00:01:15
Su perímetro 00:01:15
¿Vale? 00:01:16
Entonces 00:01:17
¿Cómo hago 00:01:17
A hacer public 00:01:18
Int 00:01:20
Doble 00:01:22
Calcula 00:01:23
Área 00:01:29
¿Cómo se calcula el área de una figura? 00:01:30
Doble área 00:01:36
Es igual a cero 00:01:38
Return área 00:01:40
Decidme cómo se calcula 00:01:41
El área de una figura 00:01:44
Depende de la figura 00:01:46
Entonces yo puedo decir 00:01:48
No lo sé hacer 00:01:50
Por defecto devuelva un cero 00:01:51
Y luego está 00:01:53
Calcula perímetro 00:01:58
¿Cómo se define el perímetro de una figura? 00:02:01
No lo sé 00:02:09
¿Alguna otra cosa que queremos que haga una figura? 00:02:10
Por ejemplo 00:02:23
Así, para hacer ejemplo 00:02:23
Quiero que devuelva sus lados 00:02:25
Como yo cuando creo una figura 00:02:27
Le devuelvo con lados 00:02:29
Pues public int getLados 00:02:30
Return lados 00:02:35
Queremos crearle una figura 00:02:41
Public 00:02:44
Figura 00:02:48
Le pasamos los lados 00:02:50
Int lados 00:02:56
Dis.lados 00:03:00
Es igual a lados 00:03:03
Esto es lo que hemos hecho hasta ahora 00:03:05
Fenomenal 00:03:10
Vamos a crear una clase que extenda esta figura 00:03:11
Entonces creo una nueva clase 00:03:15
Que es la clase cuadrado 00:03:18
Como no 00:03:26
Decimos que la clase cuadrado extendes figura 00:03:27
Se empada 00:03:34
Porque no tengo el constructor por defecto de figura 00:03:42
Por lo tanto lo tengo que hacer 00:03:50
¿Por qué se enfada aquí? 00:03:51
Es decir, que el cuadrado no tiene constructor 00:04:05
Constructor por defecto 00:04:06
Constructor por defecto que llama 00:04:11
Sin parámetro 00:04:13
Y que llama 00:04:18
¿El constructor sin parámetro de quién? 00:04:18
De figura 00:04:24
Es decir, que yo aquí tengo 00:04:25
Implicitamente public cuadrado 00:04:27
Super 00:04:30
Esto es lo que yo tengo 00:04:35
Sin haber escrito nada 00:04:38
Solo que como en figura 00:04:40
He creado un nuevo 00:04:43
¿Cómo se llama esto? 00:04:45
Un nuevo constructor 00:04:48
Que tiene 00:04:49
Algún parámetro 00:04:52
He destruido el constructor por defecto 00:04:53
El constructor sin parámetros 00:04:56
Y por lo tanto cuando el intenta hacer esto 00:04:58
Me dice oye mira no puedo 00:05:01
¿Si? 00:05:02
Entonces ahora nosotros decimos 00:05:06
si pero aunque aquí también tiene una cosa así y hace así os vale es decir que puedo tener un 00:05:08
cuadrado de siete lados entonces no me gusta esto es casi pero ahora a lo mejor en un cuadrado además 00:05:22
de saber cuántos lados hay 00:05:46
necesito un int lado 00:05:48
que es 00:05:50
cuánto es el lado del cuadrado 00:05:52
cuando yo estoy en una figura 00:05:55
genérica 00:05:59
¿tiene sentido saber el tamaño de cada uno 00:06:00
de mis lados? 00:06:03
¿por qué no? 00:06:04
y porque 00:06:08
no sé cuántos lados tengo, o sea, pues sí, lo sé 00:06:08
sé que tengo cinco lados, ¿vale? 00:06:10
pero no sé si son todos iguales, todos distintos 00:06:12
o sea, no puedo poner aquí 00:06:14
Lado 1, lado 2, lado 3 00:06:16
Entonces aquí pongo solo lados 00:06:18
Cuantos lados tengo 00:06:20
Interesante 00:06:21
Cuando estoy a este nivel 00:06:22
Lo que estoy haciendo es 00:06:25
Dame el lado del cuadrado 00:06:26
Y yo seguramente llamo 00:06:30
El constructor de figura 00:06:32
Con 4 lados 00:06:33
Porque soy un cuadrado y seguramente tengo 4 lados 00:06:34
Y en particular 00:06:37
Me acuerdo que 00:06:40
This.lado es igual a 00:06:41
O sea que ahora el constructor del cuadrado 00:06:44
Lo que recibe aquí 00:06:48
No es el número de lados 00:06:49
Porque el número de lados de cuadrado yo lo sé 00:06:51
Es el tamaño del cuadrado 00:06:54
Cuanto mide uno de sus lados 00:06:59
Ok, fenomenal 00:07:01
Entonces ahora puedo empezar a sobrescribir 00:07:04
¿Qué sobrescribo? 00:07:08
Pues 00:07:10
Esto lo tengo que sobreescribir 00:07:11
Si quiero saber sus lados 00:07:19
Puedo hacer getLados 00:07:20
Y me vale exactamente la interpretación 00:07:22
De esta clase aquí 00:07:24
Lo que tengo que hacer es esto 00:07:25
Bueno, estos dos 00:07:27
Lo voy a sobreescribir 00:07:29
Y lo que hago es 00:07:32
Area 00:07:36
Es igual a 00:07:39
Lado por 4 00:07:41
No, por lado 00:07:43
Y perímetro 00:07:43
es igual a perímetro 00:07:48
por 4 00:07:52
al lado 00:07:54
si o no 00:07:57
esto ya tiene más sentido 00:08:02
queremos hacer también 00:08:07
un rectángulo 00:08:10
justo para tener 00:08:13
otra cosa 00:08:16
una nueva clase 00:08:17
hago rectángulo 00:08:21
lo abro 00:08:24
Rectángulo que tiene 00:08:28
Int lado 1 00:08:29
Int lado 2 00:08:32
Tiene un public 00:08:35
Rectángulo 00:08:40
Int lado 1 00:08:41
Int lado 2 00:08:45
Por ejemplo 00:08:47
¿Qué hago aquí? 00:08:49
Super 4 00:08:52
¿Por qué 4? 00:08:54
Porque un rectángulo también tiene cuatro lados 00:08:56
Si era un triángulo ponía tres 00:09:00
Si era un pentágono ponía cinco 00:09:02
Súper, pero tengo que este en su figura 00:09:03
Y luego después lo que hago es que 00:09:11
This.lado1 es igual a lado1 00:09:15
Y this.lado2 es igual a lado2 00:09:19
Ahora pillo estos de aquí 00:09:25
Los pongo en rectángulo también 00:09:29
¿Cómo se calcula la área del rectángulo? 00:09:35
Algo así 00:09:40
¿Cómo se hace el otro? 00:09:41
Lado 1 por 2 00:09:44
Más lado 2 por 2 00:09:46
Quiero poner paréntesis para estar seguro 00:09:50
Fijáis, lo que ha cambiado es la implementación de estos métodos 00:09:53
Vale, fenomenal 00:10:02
Tengo mis tres clases 00:10:03
Voy a crear una clase de prueba 00:10:04
Para hacer pruebas con ellas 00:10:07
La clase 00:10:08
Prueba figuras 00:10:10
Con el main 00:10:14
Entonces ahora puedo hacer muchas cosas 00:10:15
Por ejemplo 00:10:20
Puedo hacer un cuadrado 00:10:21
Cuadrado 00:10:23
C1 es igual a 00:10:24
Ñu cuadrado 00:10:28
De tamaño 3 00:10:29
Si eso 00:10:33
C1 punto 00:10:37
Cálcula área 00:10:40
Con más 00:10:43
Un espacio 00:10:46
Más C1 punto 00:10:48
Cálcula perímetro 00:10:50
Dale, fenomenal 00:10:54
Puede hacer 00:10:56
Un rectángulo 00:10:58
Rectángulo 00:11:07
¿Vale? 00:11:14
Este es un rectángulo 00:11:16
Y luego haré 00:11:17
R1 punto calcula área 00:11:21
Y R1 punto calcula perímetro 00:11:24
¿Vale? 00:11:27
Vamos a ver si esto funciona todo bien 00:11:28
Le doy al play 00:11:30
Me sale el primer 00:11:31
El cuadrado 00:11:34
Y el rectángulo 00:11:36
Fenomenal 00:11:37
¿Si? 00:11:39
Puedo hacer 00:11:41
Figura 00:11:42
F1 es igual 00:11:45
A new figura 00:11:48
De 3 00:11:49
Tranquilamente 00:11:53
¿He usado abstract hasta ahora? 00:11:58
¿No? Este señor es una clase normal y corriente. 00:12:02
¿Eh? Es una figura de tres lados. 00:12:09
¡Mmm! ¡Qué guay! Vamos a ver qué hace esta figura de tres lados. 00:12:12
Calculamos su área y su perímetro. 00:12:16
Lanzo. 00:12:24
¿Pero cómo? Un triángulo, ¿eh? Una figura con tres lados, tiene área cero. 00:12:25
Claro, porque no sabe, hemos dicho que en la figura no podemos hacer 00:12:35
Y aquí empieza el razonamiento de por qué vamos hacia el abstracto 00:12:41
¿Tiene sentido esto? 00:12:47
O sea, ¿qué gano yo con esta cosa aquí? 00:12:49
Con haber implementado un método que luego utilizarlo no me sirve de nada 00:12:52
Porque técnicamente no lo puedo utilizar 00:12:58
Me puede decir, mira, tienes cuatro lados 00:13:02
Si vale, ¿qué eres? ¿Un cuadrado? ¿Un rectángulo? ¿Un rombo? 00:13:06
¿Y cómo calculo tu área? 00:13:09
No puedo 00:13:13
Yo lo puedo dejar así, funciona 00:13:13
Pero esto me expone a que alguien cree un triángulo así 00:13:16
Este es un triángulo, tiene tres lados 00:13:21
Probablemente es un triángulo 00:13:25
Pero no pueda calcular ni su área ni su perímetro 00:13:27
O lo calcula porque lo hace 00:13:32
Pero lo está haciendo mal 00:13:33
Por lo tanto 00:13:35
Una forma es decir 00:13:40
Es razonar y decir 00:13:43
Vale, ok, perfecto 00:13:44
Yo sé que esto no lo puedo definir 00:13:45
A nivel de 00:13:48
De figura 00:13:48
Pues entonces decido 00:13:51
Crear esta clase figura 00:13:53
Como abstracta 00:13:55
Y estos dos métodos 00:13:57
Y en vez de darle un cuerpo que no sirve de nada, decido no dárselo. 00:14:03
Decido definir que estos métodos tienen que existir en cualquier figura. 00:14:20
Cualquier cosa que extienda esta figura y que entonces es una figura tendrá que poder calcular el área, calcular el perímetro. 00:14:30
Pero 00:14:38
No te digo cómo 00:14:39
Lo sabrás 00:14:43
Lo tendrás que implementar tú 00:14:44
A la hora de concretar 00:14:47
¿Qué es esto? 00:14:48
¿Dudas? 00:14:53
Vamos a ver 00:14:55
Sí, sí, efectivamente 00:14:56
Es un listado 00:15:04
Un menú 00:15:05
Tienes que hacer esto 00:15:07
¿Vale? 00:15:10
Pero cuidado 00:15:11
Pero una pizca más 00:15:12
Porque este de aquí lo va al abstracto 00:15:14
¿Por qué no? 00:15:17
Porque este de aquí sí lo puedo implementar a este nivel 00:15:25
¿Sí? 00:15:29
Y aquí vamos a ver 00:15:32
¿Y esto? 00:15:35
Pero, si lo estoy usando 00:15:51
Este de aquí en realidad no lo puedo utilizar 00:15:54
Porque la clase lo he definido como abstracto 00:16:09
Pero en realidad, cuando yo haré un hijo, el hijo llamará a este constructor para hacer la parte de figura, pues sí que tiene sentido. 00:16:11
Si os acordáis cómo funciona un constructor, un constructor antes crea la instancia de su padre y luego lo deshijo. 00:16:22
Es verdad que yo no puedo crear una instancia figura directamente, es normal, porque esto no está implementado. 00:16:29
Pero en el momento en que yo hago una extensión 00:16:35
Y que entonces implementaré estos 00:16:39
Ya están implementados 00:16:42
El concepto de poder utilizar el constructor de mi padre 00:16:44
Es porque sigo teniendo que construir la parte de mi padre 00:16:47
Hasta si es abstracta 00:16:51
A lo mejor hasta no tengo que hacer nada 00:16:52
Pero en este caso, por ejemplo, sí que algo tengo que hacer 00:16:54
Porque lados no es abstracto 00:16:57
Lados es concreto, es algo concreto 00:17:00
Y este constructor lo que me está rellenando 00:17:02
Es la parte concreta de esta cosa 00:17:05
Una clase abstracta 00:17:07
No es una clase completamente abstracta 00:17:10
Es una clase que puede tener una parte concreta 00:17:13
Que entonces tendré que gestionar 00:17:16
Como cualquier otra clase 00:17:18
Y una parte abstracta 00:17:19
Que no existe 00:17:21
Y que tendré que implementar cuando la extenda 00:17:23
Nota para el futuro 00:17:25
Para coger con pinzas 00:17:28
Una clase completamente abstracta es una interfaz 00:17:31
Si yo tengo una clase que solo tiene métodos abstractos 00:17:37
Esa no es una clase abstracta, es una interfaz 00:17:43
Que es lo que veremos mañana o el viernes 00:17:46
¿Vale? 00:17:50
¿Qué problema me surge aquí? 00:17:53
Que ahora ya esto no lo puede hacer 00:17:58
¿Por qué no lo puede hacer? 00:18:01
Vamos a preguntárselo 00:18:05
¿Qué pasa? 00:18:07
Cannot instantiate the type figura 00:18:10
Why not? 00:18:13
Porque es abstracto 00:18:17
Lo que decíamos antes 00:18:18
No puedo hacer un new 00:18:20
De una clase abstracta 00:18:22
Fijaos que si puedo hacer 00:18:24
Un new de rectángulo y cuadrado 00:18:26
Porque no son abstractos 00:18:28
Entonces esto de figura 00:18:30
Ya no lo puedo hacer 00:18:33
Con la ventaja que ahora 00:18:34
llamar esto no tendría sentido 00:18:36
porque en una instancia de figura 00:18:39
esto no está definido 00:18:41
justo 00:18:42
por lo tanto esto 00:18:44
lo tengo que cambiar de alguna forma 00:18:46
lo que si podría hacer 00:18:48
es esto 00:18:51
ahora yo puedo crear una figura 00:18:57
genérica 00:19:02
y asociarle, ponerle dentro 00:19:03
un rectángulo del lado 5 00:19:06
lo que estoy creando 00:19:08
es un cuadrado 00:19:10
Pero lo referencio como una figura 00:19:12
¿Y cuando hago esto, qué pasa? 00:19:15
¿Estoy llamando el cálculo área de figura o el cálculo área de cuadrado? 00:19:21
De cuadrado 00:19:27
Si llamara el cálculo área de figura, explotaría 00:19:28
Porque no está, no existe, es abstracto 00:19:32
¿Y por qué llama el de cuadrado en vez de figura? 00:19:35
¿Por qué principio? 00:19:39
principio del 00:19:40
polimorf 00:19:50
muy bien 00:19:55
por el concepto de polimorfismo 00:19:57
que cuando nosotros 00:20:01
tenemos calcularia que es el mismo 00:20:02
nombre con funciones distintas 00:20:05
una abstracta y una 00:20:07
implementada y se llama 00:20:08
el de la instancia 00:20:11
no el de la referencia 00:20:12
entonces se llama 00:20:16
El de cuadrado 00:20:17
No el de la referencia 00:20:18
A figura 00:20:21
¿Sí? 00:20:22
Interesante, vale 00:20:26
Fenomenal 00:20:27
Y esto debería funcionar 00:20:28
Fijaos 00:20:31
Que yo aquí estoy 00:20:33
Utilizando un constructor de figura 00:20:35
Lo estoy utilizando aquí dentro 00:20:37
Pero no directamente 00:20:39
Lo utilizo solo cuando creo el hijo 00:20:42
Que es una clase concreta 00:20:44
y que utilizará esta parte de aquí para construir la parte concreta de la clase abstracta. 00:20:46
¿Qué más quería hacer? 00:20:57
¿Y qué pasa si yo me creo rectángulo y no creo calcularia? 00:21:00
¿Veis? Hay un error. ¿Qué error es? Vamos a leerlo. 00:21:09
El tipo rectángulo tiene que implementar el inheritado método abstracto 00:21:15
El método abstracto heredado 00:21:24
Figura.calcularia 00:21:26
Me está diciendo 00:21:28
Oye, mira, tú aquí has dicho que esto implementa figura 00:21:30
Vale, dentro de figura está un método abstracto que es calcularia 00:21:34
Y tú no lo estás implementando 00:21:38
Tienes que implementar 00:21:39
Nadie me prohíbe 00:21:41
De decir, sí, te lo implemento 00:21:50
Pero no hago nada 00:21:54
Has hecho un mal diseño 00:21:55
Una figura 00:22:07
Tiene todo lo que es 00:22:10
De forma abstracta 00:22:13
Te define como tiene que ser una figura 00:22:14
Tú estás diciendo, no, un cuadrado 00:22:15
No necesita calcular su área 00:22:17
Un cuadrado sí necesita calcular su área 00:22:19
No es una figura 00:22:21
Lo que estamos considerando nosotros como figura 00:22:25
Son figuras bidimensionales 00:22:30
Son polígonos 00:22:31
A lo mejor lo que podéis hacer es 00:22:33
Una superclase de figura geométrica global 00:22:36
Pero a lo mejor deberías tener otras cosas 00:22:40
Depende de cómo lo organizas 00:22:42
Podrías hacer que un cilindro 00:22:49
En realidad son dos círculos 00:22:51
Y un objeto raro 00:22:54
O un círculo, concretamente 00:22:56
Luego multiplicado por una altura 00:23:00
Pero probablemente figura 3D 00:23:01
Que sería un padre de figuras 00:23:05
Pues tendría también volumen 00:23:08
Por ejemplo, no lo sé 00:23:10
Eso depende de cómo lo creas tú 00:23:11
Y depende de lo que estás modelizando 00:23:16
Está claro que si estás modelizando 00:23:18
Toda la geometría 00:23:20
Pues a lo mejor tendrás todo un árbol 00:23:21
De herencia de todas las posibles 00:23:25
Figuras 2D, 3D 00:23:27
Las líneas, el punto 00:23:30
Por eso tendrás tú que 00:23:32
Gestionarlo como quieras 00:23:34
Ahora, por ejemplo, estamos 00:23:36
Haciendo el otro, lo hemos llamado figura 00:23:38
En realidad sería polígono 00:23:40
¿Sí? 00:23:42
Lo que podríamos hacer es, vale 00:23:43
Si yo hago así, esto me lo da por bueno 00:23:45
Pero claramente luego funciona mal 00:23:48
¿Sí? Cuando llego a calcularme 00:23:49
La área del rectángulo 00:23:52
Pues me da cero 00:23:54
¿Sí? Entonces 00:23:54
¿Qué estoy haciendo? Estoy 00:23:57
Jugando mal 00:23:59
¿Vale? Es decir, ¿lo puedes hacer? Sí. Ahí ya estoy haciendo un programa que solo necesita calcular perímetros. Entonces, ¿para qué ponerme a calcular el área? 00:24:04
Pero técnicamente, cuando tú extendes esta figura de aquí, tú te estás pillando el honor, entre comillas, de implementar estos métodos de aquí. Y estos métodos de aquí normalmente están descritos. Te dicen qué tienen que hacer. 00:24:17
Calculara, calculará la área de la figura relacionada a las cosas así 00:24:34
Y cuando tú extendes esta cosa en concreto 00:24:39
En un cierto momento estás haciendo como un contrato a nivel de programador 00:24:42
Diciendo, vale, te la hago bien 00:24:46
Porque si mañana llega tu compañero y dice 00:24:48
Voy a reutilizar tu clase rectángulo porque ya la has implementado en otro proyecto 00:24:51
Y resulta que tu clase rectángulo cuando calcula la área 00:24:56
La calcula devolviendo cero, pues a lo mejor no le funciona nada 00:24:59
Entonces que hago 00:25:03
Si yo tengo que hacer una cosa que solo me calcula el perímetro 00:25:05
Pues posiblemente no es esta 00:25:07
La clase que quiero implementar 00:25:09
Que quiero extender 00:25:11
A lo mejor debería extender otra cosa 00:25:11
O crearme una figura 00:25:14
Solo perímetro 00:25:16
Y allí gestionar la otra 00:25:17
O hasta si no la utilizo nunca 00:25:19
Ponerme aquí a implementar el calcular 00:25:25
Y cuando se reutilice 00:25:26
En otros proyectos 00:25:28
Pues a lo mejor se utiliza 00:25:29
Y vamos a meter otro escalón por aquí 00:25:31
¿Vale? 00:25:39
Creamos otra figura 00:25:39
O sea, otra clase que sea cuadrilátero 00:25:42
¿Existe cuadrilátero en español? 00:25:48
Vale, muy bien 00:25:51
¿Dónde pondríamos cuadrilátero? 00:25:52
¿Cuadrilátero extiende qué? 00:25:56
Figura 00:26:01
¿Sí? 00:26:02
nosotros hacemos 00:26:05
public 00:26:11
cuadrilátero 00:26:13
si creo un cuadrilátero 00:26:16
lo que tengo seguro es que es 00:26:18
super 00:26:20
de cuatro 00:26:21
todo 00:26:24
un tiempo de método 00:26:27
cuadrilátero 00:26:37
no, cuadrilátero 00:26:48
ahora si 00:26:50
vale, os gusta 00:26:51
esta cosa aquí 00:26:54
He creado un cuadrilátero 00:26:54
Un cuadrilátero la única cosa que sé 00:26:57
Es que tiene cuatro lados 00:26:59
Por lo tanto, como estén de figura 00:27:00
Pues suben de cuatro 00:27:02
¿Qué más tengo aquí? 00:27:03
Que tiene un cuadrilátero 00:27:08
Respecto a otras cosas 00:27:09
No lo sé, nada 00:27:10
Cuidado, si yo estendo figura 00:27:11
Me dice 00:27:15
Oye, mira, tienes que 00:27:16
Hacer cálcula área 00:27:17
Y cálcula 00:27:19
Perímetro 00:27:20
¿Qué tienes que hacer? 00:27:23
¿Vale? 00:27:24
Entonces lo debería hacer 00:27:26
Ahora, ¿cómo se calcula el perímetro de un cuadrilátero? 00:27:27
Así, en un rectángulo se hace cuatro por el lado 00:27:34
Pregunto 00:27:36
Ni idea 00:27:37
Tampoco 00:27:39
Lo que implica que este señor también es 00:27:41
Estoy especificando que esta es una categoría 00:27:44
Distinta 00:27:56
Estoy haciendo 00:27:57
Una jerarquía 00:27:58
Basada en 00:28:02
Aquí hay 00:28:04
Figuras 00:28:05
Aquí hay 00:28:09
Cuadriláteros 00:28:14
Cuadriláteros 00:28:16
Y ahora aquí debajo 00:28:21
¿Qué le pondré? 00:28:26
El cuadrado 00:28:28
Así, el cuadrado y el rectángulo 00:28:29
¿Sí? 00:28:32
Como tampoco es del cuadrilátero 00:28:37
No puedo 00:28:39
Si fuera que todos los cuadriláteros se calcularan con el perímetro lado por 4, podría yo aquí implementar el método abstracto, calcular perímetro, dejando el área libre. 00:28:39
Podría ir implementando uno y dejando otro abstracto. 00:28:54
Está claro que mientras que haya métodos abstractos que siguen siendo abstractos, no puede ser la clase concreta, tiene que ser abstracta también. 00:28:59
Entonces ahora me voy a cuadrado 00:29:06
En vez de extender figura 00:29:08
Extendo cuadrilátero 00:29:10
Y ahora así 00:29:13
Hasta puede hacer así 00:29:15
Y rectángulo 00:29:21
También extende cuadrilátero 00:29:26
Y también tiene así 00:29:28
Porque esto 00:29:32
Llamará super 00:29:35
Sin parámetros 00:29:37
Que será este de aquí 00:29:39
Super sin parámetros 00:29:41
Llama super de 4 00:29:43
De figura 00:29:46
Entonces le pondrá 4 lados 00:29:47
Este paso de aquí 00:29:49
Lo que me está gestionando son los lados 00:29:51
Todos los cuadriláteros son de 4 lados 00:29:54
Por lo tanto estoy seguro de esta cosa aquí 00:29:56
Esta parte de aquí la he implementado 00:29:58
Y todos los que 00:30:00
Son de 4 lados como el cuadrado de rectángulo 00:30:02
Extenderán el cuadrilátero 00:30:05
Está claro que un triángulo no extende cuadrilátero 00:30:06
El triángulo 00:30:09
Extenderá 00:30:10
Figura 00:30:11
A lo mejor podría hacer un triángulo abstracto 00:30:15
Y luego poner tres tipos de triángulos por debajo 00:30:20
Equilátero, escaleno e isócele 00:30:23
Esto funciona 00:30:26
Sigue funcionando 00:30:32
Fijaos aquí 00:30:38
Que ahora estoy haciendo 00:30:40
Un salto 00:30:43
Al abuelo 00:30:46
Figura no es el padre de cuadrado 00:30:49
Es el abuelo de cuadrado 00:30:52
¿Vale? 00:30:54
Pero cuadrado 00:30:56
Es un cuadrilátero 00:30:57
Que es una figura 00:31:00
Entonces puedo tener una referencia figura 00:31:01
A una instancia cuadrada 00:31:03
¿Si o no? 00:31:05
¿Puedo crear un cuadrilátero? 00:31:12
¿Por qué no? 00:31:16
Porque cuadrilátero es abstracto 00:31:17
No se puede hacer ni un cuadrilátero 00:31:19
Pero puedo hacer cuadrilátero x 00:31:21
Es igual a ni un rectángulo 00:31:23
Tranquilamente 00:31:25
Entonces probamos a hacer 00:31:28
Cuadrilátero 00:31:32
Que C ya lo he utilizado 00:31:38
Es igual a ni un 00:31:40
Rectángulo 00:31:42
Uno, dos, tres 00:31:44
Ningún problema 00:31:48
Y puedo pedir Q1 y Q2 aquí. 00:31:53
O sea, puedo hacerlo esto, pero así en cuadrilátero no están los métodos. 00:32:09
Extendiendo figuras, estoy importando estos abstractos, pero los estoy importando. 00:32:14
Y entonces luego estos van a cuadrado, donde cuadrado se han implementado, 00:32:27
o rectángulo, no sé cuál era, se han implementado 00:32:33
entonces se utilizarán esto 00:32:35
vale 00:32:36
y entonces aquí 00:32:38
ahora tenemos 1, 2, 3, 4 00:32:41
objetos y aquí viene 00:32:43
lo que hemos 00:32:45
hecho varias otras veces 00:32:47
es decir, ¿y qué pasa si yo hago un 00:32:49
figura 00:32:51
array 00:32:52
figuras 00:32:54
es igual a new 00:32:56
figura de 4 00:32:59
Y empiezo a poner estos objetos que he creado aquí dentro 00:33:01
Por ejemplo, en figuras de 0 pongo C1 00:33:07
Figura de 1, figura de 2, figura de 3 00:33:15
En el 1 pongo C1, en el 2 pongo R1 00:33:28
En el 2 pongo F1 00:33:33
Y en el 3 pongo Q1 00:33:37
¿Estáis viendo lo que hago? 00:33:40
Tengo un array de figuras 00:33:45
Estos son un array con 4 celdas 00:33:47
Y cada celda tiene una figura dentro 00:33:52
Y le estoy metiendo un cuadrado 00:33:54
Un rectángulo 00:33:56
Una figura 00:33:58
Y un cuadrilátero 00:34:00
Aquí dentro 00:34:01
No hay ni un figura 00:34:04
Porque en realidad distancia de figuras 00:34:06
¿Cuántas hay aquí? 00:34:09
Cero 00:34:13
Distancias de figuras 00:34:13
¿Cuántas veces se ha hecho ni un figura? 00:34:19
Cero 00:34:23
¿Por qué? 00:34:23
Porque figura es abstracta, no lo puede hacer 00:34:25
¿Cuántos cuadriláteros hay aquí dentro? 00:34:27
Cero 00:34:30
Porque cuadrilátero 00:34:31
También es abstracto 00:34:35
Y no he hecho en ningún lado ni un cuadrilátero 00:34:37
Hablando de instancias 00:34:40
¿Cuántos cuadrados hay aquí dentro? 00:34:43
Dos 00:34:47
Este es un cuadrado porque he hecho un cuadrado 00:34:48
Y F1 es un cuadrado porque he hecho un cuadrado 00:34:52
Estas son instancias de cuadrados, estos dos 00:34:55
¿Y cuántos rectángulos? 00:34:58
Dos 00:35:01
Esta es una instancia de rectángulos, esta es una instancia de rectángulos 00:35:01
Otra cosa es que hablara de referencias 00:35:04
Dentro hay referencias figuras 00:35:06
Hay referencias cuadradas 00:35:09
Hay referencias cuadrilaterales 00:35:10
Pero como instancias 00:35:12
Yo tengo dos cuadrados y dos rectángulos 00:35:14
Y toda la pregunta es 00:35:16
¿Y si ahora yo hago 00:35:19
For int is igual a cero 00:35:21
Y menor que figuras.length 00:35:26
Y más más 00:35:31
Y me digo 00:35:33
System.out.println 00:35:36
Figuras 00:35:40
De i 00:35:44
Punto 00:35:45
Calcularia 00:35:47
¿Qué calcularia se está utilizando? 00:35:49
¿Qué me da esto? 00:35:54
Porque estas son figuras 00:35:55
Entonces debería explotar 00:35:56
Sin embargo 00:36:00
Me pone las áreas 00:36:02
Cada una 00:36:04
calculada como 00:36:06
la instancia me pide 00:36:09
¿vale? si es 00:36:10
un cuadrado calculado como 00:36:12
lado por lado y si es un rectángulo 00:36:15
calculado como lado 1 por lado 2 00:36:17
¿si? 00:36:19
o sea que se está utilizando la correcta ¿por qué? 00:36:23
porque aquí subentra el 00:36:25
polimorfismo, este señor 00:36:27
de aquí calcula área, yo sé que cualquier 00:36:29
figura 00:36:31
tiene que tener calcula área 00:36:31
por lo tanto yo lo puedo llamar 00:36:35
este método sobre todos los objetos que están aquí. Pero la implementación concreta que 00:36:36
se va a utilizar es la que está en cada instancia. O sea, la implementación que se utilizará 00:36:42
para esto será de la instancia de cuadrado, de la instancia de rectángulo, de la instancia 00:36:48
de cuadrado, de la instancia de rectángulo. Si os fijáis, cosa interesante también de 00:36:53
por qué hacemos todo esto. Cuando yo hago el punto aquí, punto, me salen los métodos 00:36:59
Que puedo llamar sobre figura 00:37:04
Y figura 00:37:06
Amete calcular el cálculo de perímetro 00:37:08
Cualquier figura 00:37:11
Tiene que calcular el cálculo de perímetro 00:37:13
¿Presentada cómo? 00:37:16
No lo sé 00:37:18
Porque la figura no lo sabe 00:37:18
Pero sabe que existen estos dos 00:37:20
Por lo tanto yo puedo 00:37:23
Tranquilamente pillar mi array de figuras 00:37:25
Y hacer cálculos de área de perímetro 00:37:27
Sobre cualquiera de las figuras que están ahí dentro 00:37:29
La implementación 00:37:31
Que se usará 00:37:33
Será la que está en la clase de la Estad. 00:37:34
¿Dudas? 00:37:41
¿Queréis probar otra cosa? 00:37:51
No, no. 00:37:55
Con esto. 00:37:57
¿Queréis hacer alguna cosa? 00:37:59
¡Ay, sí! 00:38:00
¿Qué pasaría si...? 00:38:01
¿Se os ocurre algo? 00:38:04
Más o menos yo los ejemplos que quería hacer los he hecho. 00:38:06
Os he hecho varias... 00:38:09
De las cuatro clases que hemos creado. 00:38:11
Cuatro instancias. 00:38:13
Que tengan dentro de las cosas 00:38:14
Hemos visto cual no funcionan 00:38:16
Hemos creado un array de figuras 00:38:19
Podría hacer un array de cuadriláteros 00:38:21
También 00:38:23
Solo que triángulos no podría ponerlos dentro 00:38:24
Si tuviera triángulos 00:38:27
¿Dudas? 00:38:29
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
30 de enero de 2023 - 13:37
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 36″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
322.92 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid