Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 5-02-24 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 5 de febrero de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, esta clase cliente de tienda, por el hecho de heredar de cliente, simplemente por poner el extensa ahí, solo por eso, esta clase tiene no solo la propiedad dirección que hemos escrito ahí, sino que tiene las que están en la clase de la querida. 00:00:00
Estas dos, ¿vale? Y además tiene los get, los set, todos los métodos, ¿vale? Ahí está todo, ¿vale? 00:00:21
Bueno, pues esto lo hace muy cómodo, lo hace muy cómodo y vimos la comodidad de hacer esto cuando ahora ya hacíamos una aplicación que gestionaba diferentes tipos de clientes. 00:00:38
Aquí vimos la comodidad. 00:00:48
Nos, primero vimos. 00:00:50
¿Cómo se hace lo de la herencia? 00:00:52
Pues haces el extensa y lo que hay arriba lo tienes abajo, ¿vale? 00:00:53
Aquí ya hay matices que hay que meter. 00:00:57
¿Recordáis cuando vimos los modificadores de acceso que dije? 00:01:00
En realidad, tú puedes poner el private, el public, no poner nada, que no poner nada es como poner un omitido que se llama package, que significa desde el mismo paquete. 00:01:03
O el protected, y el protected dije este, nos olvidamos de él porque tiene que ver con la herencia. 00:01:14
Bueno, pues ya lo incorporaremos. 00:01:19
Vale. 00:01:22
Bueno, pues entonces nosotros lo que hemos visto es cómo heredar el extensa, las implicaciones que eso tiene. 00:01:24
Y en este ejemplito vimos que eso luego nos da ventajas, que eso nos da ventajas ahora de gestionar las cosas. 00:01:29
Nuestro main, nuestro main de aquí, ahora ya tenía un único almacén de datos, ya está. 00:01:36
Tenía solamente objetos de la clase cliente. 00:01:44
Y entonces, cuando un almacén de datos. 00:01:48
Una variable está declarada de este tipo, está declarada de este tipo, significa que puede recibir objetos de ese tipo o de cualquiera de los herederos. 00:01:51
Caben todos ahí, caben todos en esa referencia, eso es lo que significa. 00:02:02
Y ahí, esa es la ventaja, esa es la ventaja, se hace todo esto de la herencia, se hace por eso, para que en una referencia declarada de una clase puedan caer objetos de esa clase, pero también de todas las que heredan. 00:02:07
¿Vale? 00:02:20
Vamos a, lo vimos en la aplicación esta, vimos cómo yo aquí me hacía un array de clientes, pero luego en este array metía, en este array yo luego metía el que me daba la gana. 00:02:21
O metía uno de tipo cliente tienda, o metía uno de tipo cliente online, ¿vale? 00:02:39
Metíamos cualquiera de ellos, porque cabían en esa referencia, ¿vale? 00:02:45
Vamos a dejar esto más claro, ¿vale? 00:02:51
Aquí en un proyectito aparte, para que quede claro todos los matices. 00:02:59
Lo voy a llamar ejemplo básico herencia, porque es solamente para recoger los detalles de la herencia y de cómo funcionan. 00:03:12
aquí por ejemplo 00:03:21
como yo he creado el proyecto así rápidamente 00:03:29
lo digo para que estas cosas 00:03:31
os pasen y yo no tengo desmarcada 00:03:33
la casilla de generar 00:03:35
el módulo e-info, pues me ha generado 00:03:37
el módulo e-info, recordad 00:03:39
que si el archivo 00:03:41
tiene ese fichero 00:03:43
entonces es obligatorio trabajar con paquetes 00:03:44
porque si no 00:03:47
trabajas con paquetes, luego 00:03:49
la máquina virtual no va a encontrar las rutas 00:03:50
porque el módulo e-info 00:03:53
incorpora un mecanismo adicional 00:03:55
para 00:03:57
encontrar los paquetes 00:03:58
bueno, de alguna manera es una especie 00:04:01
de mecanismo que se introdujo desde Java 10 00:04:03
para organizar los paquetes 00:04:05
entonces, si tú incorporas ese fichero 00:04:07
deberías 00:04:09
incorporar en él información sobre 00:04:11
tus paquetes, y si tienes uno por defecto 00:04:13
pues entonces, si no lo dices 00:04:16
ahí, no te va a funcionar la aplicación 00:04:17
conclusión 00:04:19
como no estamos en eso y no os da igual 00:04:20
nos volváis locos 00:04:22
con esas cosas si os pasan 00:04:25
que generáis un proyecto, tiene este fichero 00:04:26
luego lo ejecutáis y dice 00:04:28
no encuentra el main, no encuentra el main 00:04:30
claro, porque no estás trabajando con paquetes 00:04:32
estás trabajando el paquete por defecto 00:04:35
si estás trabajando el paquete por defecto 00:04:37
tienes que reflejarlo en el módulo e-info, etc, etc 00:04:38
entonces no estamos en eso 00:04:41
así que 00:04:43
lo digo por, bueno 00:04:44
para que no perdáis tiempo en errores 00:04:47
de estos que hay veces que se hay una y otra vez 00:04:49
y son de chorradas de este estilo 00:04:50
vale, bueno, yo en cualquier caso voy a hacer un paquete 00:04:52
aunque no tenga el módulo e-info 00:04:55
porque siempre es buena idea ya acostumbrarse 00:04:56
a organizar uno, sus proyectos 00:04:58
sus aplicaciones en paquetes 00:05:01
donde se guarden clases 00:05:02
que significan cosas diferentes 00:05:05
pero vamos, esto como es un ejemplito 00:05:07
básico para ver lo de la herencia 00:05:09
pues va a ser una chorrada 00:05:10
vale, pues venga, vamos a ver 00:05:12
yo tengo aquí 00:05:17
mi paquete de 00:05:19
paquete, ahí 00:05:20
vale, pues tengo aquí mi paquete 00:05:33
de modelo para las entidades 00:05:37
voy a hacer una entidad cualquiera 00:05:39
de la que luego vamos a heredar 00:05:41
vale 00:05:43
por ejemplo, vamos a 00:05:44
hacer 00:05:47
una clase 00:05:49
vale, de 00:05:50
lo típico 00:05:52
que es como mejor se entiende, animal 00:05:55
venga 00:05:57
una aplicación que gestiona animales 00:05:58
pues entonces 00:06:01
uno aquí 00:06:02
las propiedades genéricas de un animal 00:06:03
las que aplican a todos 00:06:07
pues imaginaos que 00:06:09
bueno, el nombre 00:06:11
el nombre que recibe 00:06:12
vale 00:06:13
André Sile 00:06:20
si le hacemos un constructor 00:06:25
vale, entonces, vamos a escribir disculpas 00:06:29
el nombre de una planta 00:06:30
que lo escribo 00:06:31
para que creamos 00:06:31
una planificación 00:06:33
entonces, vamos a escribir 00:06:33
el nombre de un animal 00:06:35
vale, entonces, vamos a escribir 00:06:36
una planta 00:06:37
y la explicamos 00:06:39
por ejemplo, por ejemplo 00:06:40
una cosa que no se sabe 00:06:42
por ejemplo, para hacer 00:06:43
una pesadilla 00:06:44
o para hacer 00:06:45
un telet Sadly 00:06:46
como yo lo digo 00:06:48
donde voy a ponerlos 00:06:48
vamos a ponerlos en la descripción 00:06:49
en este caso un oso 00:06:49
vale, ahora 00:06:51
hay ejemplos de animales en concreto 00:06:55
vale, pues está el gato, está el perro, está el no sé qué 00:07:01
entonces ahí tendría sentido que mi aplicación recoja además 00:07:03
una clase gato para los animales que además sean gato 00:07:07
o una clase pez para los animales que a su vez sean pez 00:07:10
por ejemplo, pues entonces serían dos clases separadas 00:07:16
vale, entonces tanto pez como perro 00:07:19
como son animales, tienen nombre también 00:07:41
porque hemos decidido que todos los animales tienen su nombre 00:07:43
todo esto son decisiones que uno toma en la fase de diseño 00:07:46
hemos decidido que todos los animales tienen su nombre 00:07:49
hemos decidido que todos los animales van a tener nombre 00:07:49
por eso lo pongo en la clase animal 00:07:51
y ahora pez y perro aparte de su nombre 00:07:53
tendrán sus propias propiedades 00:07:56
entonces si realmente yo he decidido 00:07:58
cuando he descrito mi situación 00:08:00
que pez y perro sean animales 00:08:02
porque lo he decidido que lo son 00:08:04
y tiene sentido que lo sean 00:08:06
pues entonces tendremos que incorporar aquí el extends 00:08:07
vale 00:08:11
vale 00:08:19
vale, pues nada 00:08:33
ahora decidimos que propiedades les añadimos a cada uno de ellos 00:08:40
pues venga, que caracterizaría a un pez 00:08:45
que no tiene sentido que caracterice a un pez 00:08:48
que no tiene sentido que caracterice a todos los animales del universo 00:08:49
que solo lo caracteriza a ellos 00:08:52
solamente 00:08:54
el tipo de blanquia por ejemplo 00:08:55
bueno no, el acuífero en el que viven 00:09:00
por ejemplo, el acuífero 00:09:03
¿no? un perro no vive en un acuífero 00:09:05
el acuífero 00:09:08
o sea, aquí iría solo lo que caracteriza 00:09:11
al pez 00:09:17
eso no tiene sentido que vaya en animal 00:09:19
esto va aquí 00:09:20
vale 00:09:22
entonces si no hubiéramos hecho el extends 00:09:23
además tendríamos que poner ahí el nombre 00:09:26
no tenemos que ponérselo porque 00:09:28
pez ya hereda de animal 00:09:30
vale 00:09:31
¿y qué caracteriza a un perro que no caracterice 00:09:34
al resto de los animales? 00:09:36
¿qué es propio suyo? 00:09:39
cualquier chorrada 00:09:43
raza 00:09:44
vale, porque podría tener sentido 00:09:46
que uno no quiera poner en un perro 00:09:48
o raza, o sea, perdón, en un pez 00:09:49
normalmente tú no distingues los pez por raza 00:09:51
en todo caso por especie, ¿no? 00:09:53
la raza quieres que esté solo en el 00:09:55
cara a cara, te dice solo al perro 00:09:57
vale, pues ya está 00:09:59
vale, entonces 00:10:00
vale, pues nada 00:10:04
le ponemos el constructor 00:10:11
get y set de cada uno 00:10:33
constructor 00:10:42
general, vale 00:10:42
y aquí me falta el get y el set 00:10:43
vale 00:10:48
lo del get y el set es por hábito 00:10:49
porque las clases entidad 00:10:53
lo habitual es que las manejemos 00:10:54
a través de get y set, repito 00:10:59
vale 00:11:00
bueno, pues hala, yo aquí tengo un modelo muy sencillo 00:11:01
ya está, un modelo muy sencillo 00:11:05
la clase, super clase animal y subclases 00:11:06
perro y pez, vale, ya está 00:11:09
tengo un modelo muy sencillo 00:11:10
y ahora vamos a ver a través de un main pequeñito 00:11:11
pues efectivamente los matices 00:11:14
del funcionamiento de la herencia 00:11:16
a partir de un main 00:11:18
para que nos queden ya bien claros 00:11:19
vale, bueno, pues a ver 00:11:22
nos vamos a hacer un main cualquiera 00:11:24
muy pequeñito 00:11:25
venga, pues nuestro main 00:11:26
perdón 00:11:41
si, es un paquete diferente 00:11:43
porque normalmente las clases 00:11:45
que son el modelo 00:11:47
o las realidades, las entidades 00:11:48
van en un paquete, las que hacen operaciones 00:11:50
van en otro, entonces bueno 00:11:53
aunque tengamos poquitas clases 00:11:54
conviene que desde ya nos acostumbremos 00:11:56
a que suelen ir a paquetes distintos 00:11:58
en función de la 00:12:00
función que cumplen 00:12:02
en función del papel que desempeñan en la aplicación 00:12:04
pues venga, nos hacemos aquí una clase main 00:12:07
vale, pues entonces 00:12:18
todo el rollo de la herencia 00:12:24
y la importancia de la herencia 00:12:27
se recogen, se recorre 00:12:28
joder, se recogen esto 00:12:29
yo tengo aquí 00:12:31
declarada 00:12:33
una referencia de tipo animal 00:12:35
una referencia de tipo animal 00:12:40
esta 00:12:42
ahora mismo recordad 00:12:43
que lo único que hemos declarado en memoria 00:12:46
con esto es que 00:12:48
lo único que hemos hecho es esto 00:12:48
vale, esto es lo único que hemos hecho 00:12:50
hemos creado 00:12:53
una variable 00:12:53
vale 00:12:55
que se llama, esa variable 00:12:56
se llama así 00:13:00
no es el nombre que le hemos dado 00:13:01
hemos creado una variable 00:13:05
que se llama 00:13:14
esto 00:13:15
, esto es lo único que hemos creado 00:13:18
que está apuntando a qué 00:13:19
está apuntando 00:13:20
a null 00:13:22
vale, esto es lo único que hemos hecho hasta ahora 00:13:26
lo único que hemos hecho 00:13:34
hemos creado 00:13:36
una variable a 00:13:37
que es una dirección de memoria 00:13:39
pensada 00:13:42
para apuntar a un objeto animal 00:13:43
es lo único que hemos hecho hasta ahora 00:13:46
con esa dirección de memoria 00:13:47
declaración 00:13:48
este espacio en memoria ya existe 00:13:49
se llama a 00:13:51
y contiene una dirección de memoria 00:13:52
pensada para apuntar a un objeto animal 00:13:54
que todavía no existe 00:13:56
porque no hemos asignado 00:13:58
aquí no le hemos asignado nada 00:14:00
entonces por defecto 00:14:02
java lo inicializa a algún valor 00:14:04
lo inicializa a algo, por defecto 00:14:06
entonces por defecto lo inicializa a null 00:14:08
como ya sabemos 00:14:11
entonces 00:14:11
esto ahora mismo, si uno hiciera aquí 00:14:12
un system.out.println de a 00:14:18
le saldría un null 00:14:21
porque eso es lo que tiene a un null 00:14:22
¿vale? eso le saldría 00:14:24
vale, bueno, pues ahora 00:14:26
la herencia en realidad 00:14:28
en que se traduce 00:14:31
y para qué sirve 00:14:33
pues se recoge simplemente en esta idea 00:14:34
que ahora yo ya en esa referencia 00:14:36
puedo si me da la gana 00:14:38
meter un objeto animal 00:14:39
si yo quiero 00:14:42
, puedo hacer esto tranquilamente 00:14:48
y perfecto 00:14:55
ahora la referencia a se queda apuntada a un objeto animal 00:14:57
con su única propiedad nombre 00:14:59
porque el objeto animal no tiene más con lo que tiene 00:15:02
eso lo puedo hacer tranquilamente 00:15:04
pero no sólo eso 00:15:08
sino que también en esa misma referencia a 00:15:09
en esa misma referencia 00:15:12
puedo meter un objeto de cualquiera de los que herede 00:15:14
en esa misma referencia yo puedo también 00:15:18
si me da la gana 00:15:20
pues meter este objeto 00:15:25
vale, el constructor este de 00:15:27
perro, no sé ni cómo 00:15:29
lo tengo hecho 00:15:31
así, con los dos valores, vale 00:15:33
ahí 00:15:45
vale, a ver, por qué no me... 00:15:48
ah, que no importa la clase, vale 00:16:03
vale, y eso también lo puedo hacer 00:16:05
ah, es una referencia de tipo animal 00:16:09
pero perfectamente cabe en ella 00:16:11
un objeto de tipo perro 00:16:14
ningún problema, porque perro hereda de animal 00:16:15
y eso también lo puedo hacer 00:16:17
y también perfectamente 00:16:18
podría caber en A 00:16:22
podría caber en A 00:16:26
una referencia 00:16:30
un objeto 00:16:31
de tipo pez 00:16:33
bueno, pues esta es la principal referencia 00:16:41
de la herencia 00:16:48
que en una referencia de una clase 00:16:49
pueden caber objetos de esa clase 00:16:52
y de cualquiera de las subclases 00:16:55
y eso nos facilita muchísimo la vida en las aplicaciones 00:16:57
ya lo hemos visto en la del otro día 00:17:00
en la de clientes 00:17:02
yo tengo que trabajar con muchos clientes 00:17:03
tengo que trabajar con muchos 00:17:05
pues me hago un array único 00:17:06
un array único de tipo cliente 00:17:08
y en ese array meto en cada posición lo que me da la gana 00:17:10
porque cada posición será una referencia de tipo cliente 00:17:13
cada posición, aquí está 00:17:16
a clientes de cero, de uno, de dos 00:17:17
pues en cada posición meto el cliente que yo quiera 00:17:19
y no hay ningún problema 00:17:22
y ya está 00:17:24
vale, entonces ahora 00:17:25
me facilita ahí mucho las cosas 00:17:29
yo cuando, por ejemplo 00:17:32
imaginaos que ahora 00:17:33
nosotros queremos hacer un método 00:17:36
al cual se le pueden pasar 00:17:37
animales en general 00:17:40
tanto perros como gatos 00:17:42
y ese método tiene que hacer cosas con esos animales 00:17:43
vamos a 00:17:46
vamos a imaginarnos 00:17:47
vamos a hacernos una clase operaciones 00:17:48
para hacer cosas con estos animales 00:17:50
en otro paquete aparte 00:17:51
vamos a hacer otro paquete aparte 00:17:54
pues yo que sé 00:17:56
lógica 00:17:56
ah, que ya lo he llamado antes 00:17:58
bueno, no merece la pena 00:18:04
porque en este mismo paquete lógica 00:18:05
vamos a hacernos una nueva clase 00:18:08
operaciones 00:18:10
para llamarla desde el main 00:18:11
bueno 00:18:14
vale, pues en esta clase de operaciones 00:18:17
vamos a hacer un método 00:18:19
al que le podamos pasar 00:18:20
cualquier animal 00:18:23
y te diga como se llama 00:18:24
y te diga 00:18:26
te diga la inicial del animal 00:18:27
te devuelva la inicial 00:18:31
para que no sea exactamente un get 00:18:32
porque el get ya te devolvería como se llama 00:18:34
te devuelva la inicial del nombre 00:18:36
entonces, tú haces aquí un método y dices 00:18:38
a ver, necesito un método para devolver la inicial de mi nombre 00:18:40
pues venga, este método 00:18:43
me va a devolver 00:18:45
un char que es la inicial 00:18:49
y aquí el problema que viene es 00:18:51
este método que va a necesitar 00:18:58
hombre, pues le puedes pasar un perro 00:19:01
le puedes pasar un gato, le puedes pasar un pez 00:19:03
le puedes pasar lo que sea 00:19:05
entonces cuando uno declarara este método 00:19:05
si no tuviera la herencia 00:19:08
tendría que hacer 00:19:09
devolver inicial perro 00:19:11
y ponerle aquí, le paso un perro 00:19:13
devolver inicial gato 00:19:15
y aquí, le paso un gato 00:19:16
devolver inicial pez 00:19:18
y aquí, le paso un pez 00:19:20
entonces si no tuviéramos herencia 00:19:22
y tuviéramos una aplicación con muchos tipos de animales distintos 00:19:23
tendríamos que hacer un método 00:19:27
de devolver inicial para cada uno de ellos 00:19:29
y a cada uno de ellos 00:19:31
decirle que tipo de parámetro recibe 00:19:32
vale, esta sería la versión 00:19:36
cuando 00:19:39
el método devuelve la inicial del perro 00:19:41
pero la versión 00:19:44
para cuando el método devuelve la inicial de un pez 00:19:45
sería esto mismo pero con pez 00:19:48
sería una locura 00:19:49
entonces gracias a que 00:19:50
pez, perro, gato, todos 00:19:52
están bajo una super clase común 00:19:55
ese método basta con que yo haga 00:19:57
una única versión 00:19:59
hago una única versión de este método y digo 00:20:00
oye, pásame el animal que te dé la gana 00:20:03
pásame el que quieras 00:20:05
pásame el que quieras 00:20:07
y ahora esto ya, jolín 00:20:10
nos facilita la vida un montón 00:20:13
porque este método dice 00:20:15
tú pásame cualquier cosa que 00:20:16
quepa en esta referencia 00:20:18
cualquier cosa, yo ya trabajaré 00:20:20
y en esa referencia que cabe 00:20:22
caben objetos animal 00:20:24
pero también caben objeto perro, también caben objeto gato 00:20:25
cualquier cosa que herede 00:20:28
es lo que hemos 00:20:30
tratado de ejemplificar justo aquí 00:20:32
que en esta referencia 00:20:35
cabe cualquier cosa que herede 00:20:36
de animal, cualquier cosa 00:20:39
pues aquí vemos una ventaja enorme 00:20:41
yo hago un único método 00:20:43
y digo, va, pásame el tipo de animal que te dé la gana 00:20:45
no tengo que hacer una declaración para cada uno 00:20:48
no me hace falta 00:20:50
pongo aquí, pásame cualquier cosa que quepa en la 00:20:51
y ahora yo ya trabajo con ese objeto A 00:20:54
¿vale? ahora yo ya trabajo con ese objeto A 00:20:58
es que si no, sería una locura 00:21:00
sería una locura hacer una aplicación 00:21:01
que tenga que contemplar por separado 00:21:03
los diferentes tipos de clientes 00:21:05
los diferentes tipos de alumnos 00:21:08
los diferentes tipos de no sé qué 00:21:09
sería una locura hacer una aplicación así 00:21:10
y la herencia nos lo facilita 00:21:12
lo que pasa es que si no, no se puede hacer nada 00:21:14
lo que pasa es que entonces, claro 00:21:15
tenemos que 00:21:16
ahora ya saber manejarla 00:21:17
porque claro, ahora este método dice 00:21:21
vale, me has pasado un animal 00:21:23
y ahora 00:21:26
¿qué problema tiene este método ahora? 00:21:28
el primero que se os ocurre 00:21:32
yo ahora estoy programando este método 00:21:34
que es, tú recibes un animal 00:21:36
y en este caso de volver a iniciar 00:21:39
lo tendría fácil, ¿no? 00:21:42
porque el nombre del animal 00:21:45
está en la clase animal 00:21:46
está aquí 00:21:48
¿verdad? 00:21:50
la clase animal 00:21:53
la propiedad nombre está aquí arriba 00:21:54
entonces, en este caso de volver a iniciar 00:21:56
sería 00:21:59
return A.getNombre.charad0 00:22:00
¿verdad? 00:22:12
este método 00:22:13
sería así 00:22:15
entonces, yo ahora llamo a este método 00:22:16
pasándole perro, gato, lo que me dé la gana 00:22:18
¿verdad? 00:22:20
vamos a verlo 00:22:22
imaginaos que 00:22:23
me voy a hacer dos referencias 00:22:26
A1 y A2 00:22:28
en la referencia A1 00:22:29
voy a meter 00:22:32
un perro 00:22:34
y en la referencia A2 00:22:37
voy a meter un pez 00:22:39
¿vale? 00:22:41
tengo dos objetos animal 00:22:43
¿vale? 00:22:44
el A1 00:22:45
y el A2 00:22:45
A1 y A2 00:22:47
como veis están declarados los dos de clase animal 00:22:47
¿vale? 00:22:49
bueno, pues entonces yo ahora puedo llamar 00:22:51
tranquilamente al método 00:22:53
con cualquiera de los dos objetos 00:22:54
devolver inicial 00:22:56
y le paso A1 00:23:00
y estupendo 00:23:01
al compilador le parece genial 00:23:03
yo no le he pasado un animal 00:23:06
en realidad 00:23:08
o sea, aquí 00:23:09
operaciones dice que necesito un objeto de clase animal 00:23:09
eso es lo que dice 00:23:13
el método de clase animal 00:23:15
¿vale? 00:23:15
es la declaración del método 00:23:15
que necesita un objeto de clase animal 00:23:16
y yo en realidad le estoy pasando 00:23:17
uno que es un perro 00:23:20
pero no pasa nada 00:23:23
porque perro heredado de animal 00:23:25
luego estupendo, ahí cabe perfectamente 00:23:26
cuando le pase el pez 00:23:28
pues exactamente igual 00:23:31
cuando le pase el pez 00:23:32
pues lo mismo 00:23:37
le puedo pasar un pez, no pasa nada 00:23:38
cae 00:23:41
cae en la caja de animal perfectamente 00:23:42
porque A2 es un pez 00:23:45
que pez hereda 00:23:46
si no hubiera un extens 00:23:47
pues sería imposible hacer todo esto 00:23:49
claro 00:23:50
¿vale? 00:23:51
bueno, lógicamente si yo ejecutara esto 00:23:53
como no lo he mostrado en un este 00:23:55
pues no va a salir nada 00:23:57
vale 00:24:13
vale 00:24:14
en este caso nos sale 00:24:14
saldrá P en ambas, vamos a llamarle a este 00:24:15
de otra manera 00:24:17
al P 00:24:17
vale, y todo fenomenal, me sale P y X 00:24:19
que efectivamente son las dos iniciales 00:24:27
P y X, vale 00:24:29
hasta aquí está claro, ¿no? 00:24:30
todo nos encaja, todo estupendo, no vemos ninguna 00:24:33
cosa rara, y ya vemos 00:24:35
la primera 00:24:37
de las fortalezas de la herencia 00:24:38
que no hemos tenido que hacer métodos 00:24:40
diferentes para devolver inicial 00:24:43
para cada uno, no 00:24:45
el mismo yo le paso al animal, vale 00:24:46
hasta ahí vamos bien, bueno 00:24:48
vale, vamos a imaginar 00:24:51
que ahora lo que quiere hacer este método 00:24:53
en realidad 00:24:54
depende del animal que sea 00:24:56
me explico, por ejemplo 00:25:00
vamos a suponer que 00:25:02
tenemos 00:25:04
el perro, tiene un 00:25:06
método en particular 00:25:09
que fuera 00:25:10
pues ladrar 00:25:11
ya está 00:25:13
y el pez 00:25:28
tiene un método suyo 00:25:32
que es por lo que hacen los peces 00:25:34
que no sé lo que hacen los peces 00:25:36
algo harán 00:25:39
digo yo 00:25:40
nada 00:25:41
y el pez 00:25:41
tiene un método suyo que es por lo que hacen los peces 00:25:42
pues el pez 00:25:43
nada 00:25:48
que el perro, no nada 00:25:48
vale 00:25:49
entonces la acción del perro 00:25:50
es ladrar y la acción del pez 00:25:56
es nadar 00:25:58
vale 00:25:59
vale, entonces estos métodos lógicamente 00:26:00
no caen en animal, no tendría 00:26:10
ningún sentido que cayeran en animal 00:26:11
no tendría ningún sentido 00:26:13
porque no todos los animales ladran 00:26:15
y no todos los animales 00:26:17
eh, nadan 00:26:19
entonces, esos métodos sí que están 00:26:21
solamente en cada clase 00:26:23
sin embargo, sí puede haber algo 00:26:25
que sólo haga un animal 00:26:27
perdón, que hagan todos los animales 00:26:29
pues todos los animales comen 00:26:31
eso sí que lo hacen todos 00:26:33
entonces, en la clase animal sí podría haber un método 00:26:35
en esta clase animal 00:26:43
sí podría, tendría sentido 00:26:48
haber un método 00:26:49
que fuera a comer 00:26:50
porque todos comen 00:26:57
entonces lo pongo ahí 00:26:58
y ya todos los animales 00:27:00
tienen ese método 00:27:02
aunque yo no lo escriba específicamente 00:27:04
pero como ladrar es sólo de perro, ese va en perro 00:27:06
como nadar es sólo de pez, ese va en pez 00:27:09
vale 00:27:12
hasta que el perro sea un perro 00:27:12
está que bien, ¿no? 00:27:13
esto como diseño pues tendría sentido 00:27:14
yo meto en la superclase lo que hacen todos 00:27:16
y en las subclases lo que es específico de cada uno 00:27:19
está ahí bien 00:27:22
vale, pues nos volvemos a nuestra clase de métodos 00:27:23
imaginaos que ahora hay 00:27:27
que yo quiero hacer en esta aplicación 00:27:29
quiero hacer un método 00:27:31
que ejerza o que realice 00:27:33
la acción propia de cada animal 00:27:35
la acción propia del perro puede ser ladrar 00:27:39
la acción propia del pez, nadar 00:27:41
la acción propia del gato, maullar 00:27:43
hay algo que en mi modelo de datos significa 00:27:45
su acción natural 00:27:47
entonces, ¿cómo expreso yo eso? 00:27:49
pues podría poner 00:27:52
vale, pues mira, me hago un método que sea 00:27:53
public static 00:27:56
realizar su acción, la que sea 00:27:58
nadar, lo que sea 00:28:00
y ahora, ¿quién va a realizar esa acción? 00:28:06
cualquier animal 00:28:08
cuando yo llame a realizar acción para un perro 00:28:10
pues la realizará un perro 00:28:12
todos tienen su acción 00:28:13
ladrar, maullar 00:28:15
entonces, tendría sentido que yo me hiciera aquí un método 00:28:17
y dijera, venga, pásame un animal 00:28:22
pásame un animal 00:28:26
vamos a ver 00:28:28
cualquier animal 00:28:31
esta es la misma idea que el de arriba 00:28:33
cualquier animal puede hacer este método 00:28:35
pásame cualquier animal 00:28:36
y yo aquí ya me encargo de que realice su acción 00:28:38
sea ladrar, sea no sé qué 00:28:41
bueno, pues estupendo 00:28:43
sería esa la idea 00:28:45
y así no tengo que hacer un método para cada 00:28:46
ladrar perro, al que le paso un perro 00:28:49
maullar gato, al que le paso un gato 00:28:51
nadar pez, al que le paso un pez 00:28:53
¿para qué voy a hacer un método 00:28:55
para cada animal 00:28:57
para que realice su acción? 00:28:59
si con esto de la herencia hemos visto 00:29:01
que yo en esta referencia cae cualquier animal 00:29:03
pues me hago un único método, realiza la acción 00:29:07
y que realice la acción que sea 00:29:09
ya dependerá de este animal cual sea 00:29:11
bueno, puede tener sentido 00:29:13
de hecho era la idea 00:29:15
ahorrarnos tener un método para cada uno 00:29:17
pero ¿qué nos pasa? 00:29:19
que nos ponemos aquí a realizar la acción 00:29:21
y nos volvemos locos 00:29:23
porque A, la referencia 00:29:25
oye, el método este me dice 00:29:27
a ver, A 00:29:29
yo sé que es un animal 00:29:31
pero no sé más 00:29:33
no sé más 00:29:35
entonces si yo veo, atiendo 00:29:37
a los métodos de A 00:29:39
a los métodos de A 00:29:41
a los métodos de A 00:29:43
si yo atiendo a los métodos de A 00:29:47
si yo atiendo a los métodos de A 00:29:49
pues es que sólo veo lo que tiene 00:29:51
la clase animal 00:29:53
sólo veo lo que tiene la clase animal 00:29:55
tiene nombres, tiene comer 00:29:57
porque todos comen 00:29:59
pero yo solamente puedo llamar a lo que haya en A 00:30:01
no puedo llamar a la específica 00:30:03
no puedo llamarlo 00:30:05
entonces aquí nos encontramos 00:30:07
con un problema gordo a la hora de hacer este método 00:30:09
¿verdad? 00:30:11
¿qué decimos, jolines? 00:30:13
es que depende 00:30:15
¿qué hago? ¿a punto ladrar? 00:30:17
no puedo, porque ladrar es un método 00:30:19
que está en perro, no está en animal, no puedo 00:30:21
¿hago a punto nadar? 00:30:23
no puedo 00:30:25
es que no existen, no existen esos métodos 00:30:27
aquí, pero entonces 00:30:29
diríamos, jolín, esto no tiene sentido 00:30:31
entonces, ¿para qué te vale esto? 00:30:33
aquí te ha valido muy bien 00:30:35
porque nombre está en todos los animales 00:30:37
pero cuando 00:30:39
quieres tú invocar 00:30:41
a cosas específicas de cada objeto 00:30:43
pues no te vale este invento 00:30:45
no te vale, sólo puedes invocar 00:30:47
a lo que está en animal 00:30:49
¿no? 00:30:51
¿entendéis el problema, no? 00:30:53
bueno, pues tiene que haber 00:30:55
alguna manera para que esto no se desmorone 00:30:57
digamos, jolín, pues hemos empezado a hacer algo 00:30:59
que luego resulta que la potencia que tienes es muy limitada 00:31:01
tiene que haber algo 00:31:03
que nos permita distinguir 00:31:05
dada una referencia 00:31:07
de una superclase 00:31:09
que nos permita distinguir 00:31:11
si el objeto se instanció 00:31:13
como perro, o se instanció como gato 00:31:15
o se instanció como pez 00:31:17
porque eso es lo que nos falta aquí 00:31:19
lo que necesitamos aquí saber 00:31:21
es esto 00:31:23
esto es lo que necesitaríamos saber 00:31:25
¿qué tipo de objeto 00:31:29
es A? 00:31:31
o lo que es lo mismo, sabemos que es 00:31:33
pertenece a animal, o sea, está declarado 00:31:35
como animal, con lo cual sabemos 00:31:37
que es o de clase animal 00:31:39
o de cualquiera de las superclases 00:31:41
eso sí que lo sabemos sí o sí 00:31:43
que A o es de animal, o es de cualquiera de las subclases 00:31:45
ahí no hay otra, tiene que serlo 00:31:47
porque una referencia A 00:31:49
cae en la propia clase animal 00:31:51
y todas las subclases, eso lo sabemos 00:31:53
pero claro, tenemos que saber cuál de todas esas 00:31:55
esa es nuestra gran duda 00:31:59
¿a qué subclase pertenece? 00:32:03
porque si no lo sabemos 00:32:05
si no podemos averiguarlo 00:32:09
no podemos decidir 00:32:11
a qué método llamar, si llamar a ladrar 00:32:13
llamar a nadar, no podemos saberlo 00:32:15
esta pregunta hay que poder responderla 00:32:17
Java nos tiene que dar una manera 00:32:19
de poder responder a esta pregunta 00:32:21
yo sé que A es una referencia 00:32:23
de animal, pero en el momento de crear 00:32:25
en el momento de hacer el new 00:32:27
cuando hiciste el new, ¿qué new hiciste? 00:32:29
hiciste new perro, hiciste new gato 00:32:31
me lo tienes que decir, tengo que encontrar 00:32:33
una manera de resolver eso 00:32:35
porque si no, no sé si ladrar a perro 00:32:37
llamar a ladrar, llamar a nadar, etc 00:32:39
bueno, pues efectivamente 00:32:41
hay una sentencia 00:32:43
para resolver esa pregunta 00:32:45
porque si no, esto no vale para nada 00:32:47
vale, pues ¿qué sentencia es? 00:32:49
es esto 00:32:53
que se usa así 00:32:55
es como un operador 00:32:59
condicional 00:33:01
y se usa así 00:33:03
por ejemplo 00:33:05
esta sería la condición 00:33:09
habría que meterla en un if 00:33:11
o en un while donde fuera 00:33:13
porque es una condición, es un operador condicional 00:33:15
esta sería la condición 00:33:17
si A se instanció 00:33:19
como objeto perro 00:33:21
esto será true 00:33:23
si A 00:33:25
el objeto que tiene dentro se instanció 00:33:27
con el new como perro, dará true 00:33:29
si se instanció como perro 00:33:31
pues esto dará true 00:33:33
si A se instanció con el new como gato 00:33:35
sabemos que se puede instanciar de cualquier cosa 00:33:37
que sea subclase de animal, de cualquiera 00:33:39
pues con esta condición 00:33:41
podemos averiguarlo 00:33:43
entonces 00:33:45
uno podría decir, ah vale, por fin resuelto 00:33:47
si A es un objeto 00:33:49
que se instanció como perro 00:33:51
tendré que hacer el import 00:33:55
si se instanció como perro 00:33:57
si se instanció como perro 00:33:59
pues entonces 00:34:01
ahora yo ya 00:34:03
puedo partir de la base 00:34:05
de que A es un perro 00:34:07
y hacer todo lo necesario 00:34:09
para poder llamar a su método ladrar 00:34:11
entonces 00:34:13
todo lo necesario es esto, a punto ladrar 00:34:15
no me corrijas 00:34:21
compilador, así 00:34:23
todo lo necesario es esto 00:34:25
nos vamos 00:34:27
no, estamos en las mismas 00:34:29
que el compilador, el compilador no entiende 00:34:31
de tiempo de ejecución 00:34:33
de cómo son las cosas 00:34:35
el compilador entiende sólo de cómo se han declarado 00:34:37
y el compilador se emperra y dice 00:34:39
que no, que no llames a ladrar 00:34:41
que A está declarado 00:34:43
como animal, pues yo solamente 00:34:45
te dejo llamar a métodos 00:34:47
que estén animal 00:34:49
pero claro, tú sabes 00:34:51
porque te lo está diciendo 00:34:53
esta condición, tú sabes 00:34:55
que A sí que se instanció como perro 00:34:57
lo sabes porque esto es true 00:34:59
entonces como lo sabes 00:35:01
te puedes permitir 00:35:03
y aquí sí que lo tienes que hacer 00:35:05
te puedes permitir hacer un casting 00:35:07
aquí sí que es lo que el eclipse 00:35:09
se ha empeñado en hacérmelo rápidamente 00:35:11
aquí sí que te puedes 00:35:13
permitir hacer un casting 00:35:15
oye, yo sé que A es un perro 00:35:17
y que haciendo este casting no la cago 00:35:19
porque sé que lo es 00:35:21
sé que lo es 00:35:23
porque si no, no habría dado true esto 00:35:25
entonces como sé que lo es 00:35:27
me hago 00:35:29
el casting a perro 00:35:31
ala, casting a perro 00:35:33
y no va a fallar 00:35:35
y ahora ya esto, después del casting 00:35:37
al ser ya un objeto perro 00:35:39
el compilador dice, vale 00:35:41
estupendo, ya sí que te dejo llamar a ladrar 00:35:43
ya sí que te dejo llamar a ladrar 00:35:45
vale 00:35:47
bueno, vamos a pararlo aquí 00:35:49
bueno, vamos a pararlo aquí 00:35:57
vale 00:35:59
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
5 de febrero de 2024 - 20:17
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
36′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
142.71 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid