Saltar navegación

Herencia 2.3 - 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 14 de enero de 2025 por Stefano C.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

porque tengo miedo que luego no funcione el después de haber hecho el zoom no funciona 00:00:00
grabación vale entonces estamos aquí sí entonces siempre siempre siempre hay una llamada al 00:00:06
constructor superior o no lo indicó entonces en automático me hace un súper vacío o si no 00:00:14
lo indicó explícitamente y agradece el súper que yo quiero constructor herencia si no se 00:00:19
indica específicamente, pues 00:00:26
aquí, ¿vale? si yo hago un alumno 00:00:27
con estas cosas aquí y hago esta cosa aquí 00:00:30
pues en 00:00:32
implícitamente 00:00:32
aquí habría hecho una llamada invisible 00:00:36
a super, ¿sí? 00:00:38
y luego hago esto 00:00:39
si en vez lo indico específicamente, pues aquí 00:00:40
estoy diciendo esto, entonces aquí no se hace 00:00:44
la llamada super vacío 00:00:46
¿sí? 00:00:47
¿dudas? 00:00:50
¿preguntas hasta aquí? 00:00:52
vale, entonces 00:00:55
Si hemos entendido un poquito de herencia, hemos entendido un poquito de generalización, especificación, hemos entendido cómo funciona el constructor, hemos entendido que yo tengo por arriba unos parámetros, unos métodos y unos atributos que se reutilizan en las clases heredadas. 00:00:57
Vamos a ver 00:01:18
Unas cosillas un poquito más 00:01:20
Finas 00:01:22
¿Vale? Unas 00:01:24
Cosas que a lo mejor hasta se os ha ocurrido 00:01:26
Pero, no sé 00:01:28
¿Vale? Que se puedan hacer 00:01:30
Dentro del mundo de la herencia 00:01:32
¿Vale? Que son los shadowing 00:01:34
Y el overriding 00:01:36
El overriding lo hemos hecho ya 00:01:37
¿Vale? Era equals, cuando hicimos equals el viernes 00:01:39
Eso hemos 00:01:42
Sobrescrito, override 00:01:43
un método de la clase superior 00:01:45
¿vale? lo veremos después otra vez 00:01:48
y lo formalizaremos 00:01:50
pero es ese el concepto 00:01:52
yo tengo equals de object 00:01:53
pero quiero que cuando comparo dos strings 00:01:55
por ejemplo, no sea el igual igual 00:01:58
la comparación entre dos strings 00:02:00
sino quiero que ir por carácter por carácter 00:02:02
y demostrar que los carácteres son los mismos carácteres 00:02:04
por un lado y por el otro 00:02:07
entonces sobre escribo el método equals en string 00:02:08
para que cuando se haga un equals en tres strings 00:02:12
No se usa el equals de object 00:02:15
Mas se usa el equals de string 00:02:17
Lo veremos 00:02:19
¿Vale? Otra vez 00:02:21
Pero antes vamos a ver el shadowing 00:02:22
Que es una cosa que 00:02:25
En mi experiencia 00:02:27
De programador he utilizado muy poco 00:02:29
Pero existe 00:02:31
¿Vale? Entonces como tal 00:02:33
A lo mejor en algunas clases 00:02:35
En algunos proyectos pues lo vais a 00:02:37
Encontrar y por lo tanto 00:02:39
Tienes que saber que es 00:02:41
¿Vale? 00:02:42
tanto shadowing como overriding 00:02:43
se basan sobre el hecho de 00:02:46
reescribir 00:02:48
en una clase derivada 00:02:49
algo que ya existía 00:02:52
en una clase padre, en una clase base 00:02:54
cuando es shadowing 00:02:56
se está hablando que 00:03:01
un atributo de la clase 00:03:02
que hereda 00:03:04
tiene el mismo nombre 00:03:05
de un atributo de la clase base 00:03:08
yo tenía 00:03:11
string nombre en la clase base 00:03:12
y ahora en la clase 00:03:15
que hereda, en la subclase 00:03:18
vuelvo a utilizar nombre 00:03:22
pero con otro atributo, por ejemplo 00:03:24
int nombre 00:03:27
mientras que el overriding 00:03:28
es cuando tengo un método en la clase base 00:03:35
y este método se vuelve a declarar 00:03:38
con el mismo nombre los mismos atributos 00:03:41
dentro de la clase hija 00:03:44
cuidado que esto no es un overload 00:03:46
porque no se puede 00:03:48
escribir dos veces 00:03:49
el mismo método con el mismo 00:03:51
nombre y los mismos parámetros 00:03:54
es un override 00:03:56
lo estoy reescribiendo 00:03:58
y veremos después 00:04:00
para que me sirve y para que es útil 00:04:02
lo más usual 00:04:04
cuando se produce la estructura es que 00:04:06
se describe el método 00:04:07
el overriding es muy utilizado 00:04:09
en los shadowing yo lo he visto pocas veces 00:04:12
ejemplo de shadowing 00:04:16
tengo la clase persona con public string nombre juan 00:04:17
y luego tengo la clase alumno 00:04:22
que extiende persona 00:04:24
pero public int nombre es igual 00:04:26
a un número 00:04:29
veis que el parámetro se llama igual 00:04:31
pero en la clase persona era un string 00:04:33
y en la clase alumno es un int 00:04:36
esto 00:04:39
hace shadowing, hace shadow, es sombra. 00:04:40
Es como si proyectara la sombra de este parámetro aquí sobre este de aquí. 00:04:43
Este se queda oculto detrás de la sombra de este señor de aquí. 00:04:50
Es decir, que si yo ahora uso un alumno, me espero que el nombre sea un entero, 00:04:56
y si uso una persona, me espero que el nombre sea un string. 00:05:01
Entonces, por ejemplo, si me creo un alumno A, 00:05:08
que es un alumno y luego me creó otra variable p de tipo persona que apunta al 00:05:12
mismo objeto lo puede hacer esto momento paint y yo aquí tengo un alumno 00:05:19
que apunta a un objeto alumno y ahora hago esta cosa de aquí persona p es 00:05:31
igual a lo que estoy haciendo este es a lo que estoy haciendo es crearme una 00:05:41
Una variable p 00:05:48
De tipo persona 00:05:49
Que apunta a este mismo objeto 00:05:52
Lo puedo hacer 00:05:56
Pero si este es un objeto alumno 00:05:57
¿Cómo puedo ponerlo en una variable de tipo persona? 00:06:01
Y entonces 00:06:09
Entonces 00:06:09
Alumno 00:06:11
Es una persona 00:06:13
Allá donde puedo usar 00:06:16
Persona 00:06:20
Puedo poner un alumno 00:06:21
Lo puede hacer, pero cuidado 00:06:22
Que ahora esta de aquí es una referencia a una persona 00:06:24
Esta de aquí es una referencia a un alumno, es un poco distinto 00:06:26
¿Están de acuerdo? 00:06:28
Entonces 00:06:31
Si después de haber declarado estos dos 00:06:32
Y haber hecho 00:06:35
Estas dos líneas aquí 00:06:36
Hago system.out.println 00:06:40
P.nombre 00:06:42
Usando esto 00:06:44
Lo que escribe este println 00:06:46
Será Juan 00:06:48
Porque estoy usando este 00:06:49
nombre, porque es un nombre 00:06:52
de una persona, sí, pero es 00:06:54
una instancia de un alumno, sí 00:06:56
pero lo estoy usando como si fuera una persona 00:06:58
en el shadowing, porque luego veremos que 00:07:00
en el overriding no es así 00:07:02
sin embargo, si 00:07:04
uso directamente una 00:07:08
referencia de tipo alumno 00:07:10
a punto nombre, usará 00:07:11
este nombre de aquí y me lo escribirá 00:07:14
esto es 00:07:19
la utilidad 00:07:20
real, en campo real 00:07:23
de esta cosa, no me queda clara 00:07:24
¿vale? pero en un cierto sentido 00:07:27
yo podría, estaría dando al mismo concepto 00:07:30
al mismo nombre, la misma variable nombre, dos posibles valores 00:07:33
hasta distintos a nivel de 00:07:36
de lo que contiene, ¿sí? y que luego 00:07:39
dentro de aquí, dependiendo de si uso 00:07:42
una referencia a persona o una referencia a alumno 00:07:45
puedo sacar una o la otra cosa 00:07:49
Por ejemplo, en un sistema de corrección de exámenes 00:07:51
La persona tiene su nombre, pero el alumno tiene un número 00:07:56
De esta forma, cuando yo profesor accedo al alumno 00:08:00
El sistema me hace ver su nombre como alumno 00:08:03
Entonces yo no sé quién es 00:08:07
Y corrijo el examen sin saber quién es 00:08:09
Pero luego, cuando el sistema tiene que escribir a este alumno 00:08:12
Es decir, hacer un listado de saber cuánto alumno ha sacado, pues entonces lo trata como persona. 00:08:18
Y entonces me aparecerá, en vez de su numerito, su nombre. 00:08:26
No sé si me explico como ejemplo. 00:08:31
Entonces estaría utilizando el mismo objeto, el mismo objeto alumno, pero al profesor no le hago saber quién es. 00:08:35
Así cuando corrige, no tiene, este me cae bien, este me cae mal, lo corrijo mejor o peor. 00:08:40
Sin embargo, cuando luego hago el listado 00:08:45
Tengo que saber quién es 00:08:47
Para luego guardarlo donde sea 00:08:48
Entonces uso la persona 00:08:50
A posteriori, después, cuando se ha cerrado la corrección 00:08:52
Y ya no se pueden modificar las notas 00:08:55
Pues a este punto 00:08:56
Ya lo trato como persona y sé quién es 00:08:57
¿Se entiende? 00:09:00
Pues un programa como esto 00:09:02
Un caso como esto 00:09:04
Lo podría trabajar haciendo una cosa de este estilo 00:09:05
Haciendo shadowing 00:09:09
De este valor de aquí 00:09:10
Aquí dentro 00:09:12
¿Dudas? 00:09:13
Si definimos una subclase un atributo del mismo nombre y tipo que la superclase, la de la superclase queda oculta, ¿vale? La variable, el atributo de la superclase queda oculto detrás del nuevo variable que tiene el mismo nombre que le hace sombra al otro, ¿vale? 00:09:16
Podemos acceder a la variable de la superclase o de la subclase de la superclase usando this is super 00:09:42
Si yo uso dentro de alumno this.nombre estoy usando este nombre de aquí 00:09:49
Si dentro de alumno quisiera usar este nombre de aquí podría usar super.nombre 00:09:59
Esta es una versión distinta del uso de super 00:10:06
Nosotros antes usábamos super con paréntesis para utilizar el constructor de la superclase. 00:10:10
Aquí estamos usando super.nombre. 00:10:18
Estamos usando un atributo de mi clase superior. 00:10:20
No sería this.nombre porque this.nombre haría referencia al que he hecho aquí que está haciendo shadowing. 00:10:26
Entonces no vería el de la superclase. 00:10:33
Si quisiera desde alumno acceder a este de aquí podría hacerlo con super.nombre. 00:10:35
En vez de utilizar este objeto como dis, utilízamelo como si fuera de la superclase y accede a su campo nombre. 00:10:41
Shadowing, ¿vale? Entonces, veamos cómo se puede utilizar estas cosas. 00:10:55
Tengo la clase abuela, entre comillas, que es transporte. 00:10:59
Tengo dos clases que heredan de transporte, que son tren y vehículo. 00:11:04
Y luego tengo la clase que heredan de vehículo, que son moto y coche, ¿vale? 00:11:08
Nos ponemos en coche. Imaginémonos que en cada uno de estos niveles hemos hecho shadowing del atributo nombre anterior, ¿vale? Si es en transporte, nombre vale terrestre. Si es vehículo, nombre vale turismo. Y si es coche, nombre vale Ferrari, mi coche, ¿vale? 00:11:13
Entonces, ¿cómo acceder a variables ocultas desde la clase hija? 00:11:39
Es decir, si yo estoy en coche y uso nombre, ¿qué me pondrá? 00:11:45
Si yo estoy dentro de coche y uso nombre, ¿nombre cuánto valdrá? 00:11:53
¿Qué valdrá? 00:11:59
Hola, como Nuri. 00:12:04
Ferrari. 00:12:09
¿Sí? 00:12:11
Porque dentro de coche la definición de nombre es Ferrari. 00:12:11
¿Sí? 00:12:16
Ahora, si yo dentro de coche 00:12:16
Estoy siempre dentro de coche 00:12:19
Uso dis.nombre 00:12:21
¿Cuánto me vale dis.nombre? 00:12:22
System.at.pln 00:12:24
Dis.nombre 00:12:26
¿Qué me escribe? 00:12:27
Ferrari 00:12:30
El nombre es dis.nombre 00:12:30
Estoy siempre en coche 00:12:34
¿Sí? 00:12:35
Ahora, si yo pongo super.nombre 00:12:37
¿Qué me escribe? 00:12:39
Turismo 00:12:41
Porque desde aquí 00:12:41
Si hago super 00:12:44
Me estoy yendo a mi superclase, entonces ahora soy un vehículo, y cuando accedo a vehículo.nombre, encontraré esto. 00:12:46
Entonces me escribirá turismo. 00:12:57
Y si yo hago vehículo de this.nombre, turismo. 00:13:00
Porque estoy diciendo, pilla este objeto, pero castéalo a un vehículo, o sea, trátalo como si fuera un vehículo. 00:13:07
Y ahora accede a su campo nombre 00:13:14
Por lo tanto accedo a este nombre 00:13:17
¿Puedo hacer super punto super punto nombre? 00:13:19
No, ¿por qué? 00:13:25
Porque está una línea roja en el medio 00:13:26
Y porque está escrito mal 00:13:30
¿Sí? 00:13:32
Entonces esto no 00:13:34
¿Cómo hago entonces acceder a este de aquí? 00:13:34
Pues la misma cosa que he hecho aquí 00:13:37
Pero hago con transporte 00:13:39
O sea, pillas este objeto 00:13:42
Dices, castéalo a transporte 00:13:43
O sea, considéralo como fuera un transporte. ¿Lo puedo hacer? Sí, porque coche es un vehículo y vehículo es un transporte. 00:13:46
Por lo tanto, coche es un transporte. Lo puedo hacer. Y a este punto accede al nombre. Estoy accediendo a este nombre. 00:13:53
¿Se entiende? Entonces, si yo declaro otra vez el mismo atributo, fijaos que aquí le hemos cambiado también el tipo, 00:14:02
Pero no es necesario, ¿vale? En varias clases que se heredan, los nuevos, los más heredados, pues hacen, los nuevos definidos hacen sombra a los que ya existían, a los heredados, ¿sí? 00:14:15
Pero hay formas de poder acceder a eso si yo quiero 00:14:34
¿Dudas hasta aquí? 00:14:38
Esto más o menos es el shadowing 00:14:47
El otro tema es el overriding 00:14:48
¿Vale? El sobreescribir 00:14:52
La escritura de un método es útil para ampliar la funcionalidad de un método 00:14:55
O particularizar las funcionalidades de un método a la clase derivada 00:15:00
Es decir, el overriding es lo mismo 00:15:04
Solo que en vez de estar reescribiendo un parámetro, un atributo 00:15:06
Estoy reescribiendo un método 00:15:11
Y lo puedo usar para dos cosas. La primera es que el método que estaba en persona hace algo, pero no es suficiente para alumno. 00:15:13
Alumno debería hacer ese algo y algo más. Por ejemplo, yo tengo el método Descríbete. 00:15:23
Pues cuando uso Descríbete en persona, me dirá me llamo Estefano. Vale, porque tiene nombre. 00:15:33
Ahora, alumno tiene también sus notas. 00:15:41
Entonces, si yo le digo, alumno, descríbete, me dice, me llamo Estefano, me falta algo. 00:15:43
Porque debería decir, me llamo Estefano y mis notas son 3, 7 y 9. 00:15:47
¿Sí? 00:15:53
Por lo tanto, yo lo que puedo hacer es sobrescribir el método de escríbete de persona, 00:15:53
diciendo, oye, mira, haz lo mismo que hace persona y algo más. 00:15:59
Te describes, hola, soy Estefano, y luego me pones la lista de tus notas. 00:16:04
Esto sería el primer caso, ampliar la funcionalidad de un método 00:16:09
La segunda opción podría ser cambiar o particularizar la cosa 00:16:13
Por ejemplo, imaginaos una situación de este estilo 00:16:23
Yo tengo aquí animal y aquí tengo que heredan de animal gato y perro 00:16:28
como no. Ahora, yo tengo en animal un método que es produce sonido. Ahora, cuando un animal 00:16:49
produce un sonido, yo no sé qué animal, qué sonido hace. Entonces pondrá system.auto.println 00:17:13
Este animal produce un sonido 00:17:21
Ahora, cuando yo voy a hacer el gato 00:17:23
Yo no quiero que ponga 00:17:30
Este animal produce un sonido 00:17:32
Porque sé que hace el gato 00:17:34
Entonces, sobreescribo este método 00:17:36
Pero no diciendo 00:17:41
Haz lo mismo que hace un animal y algo más 00:17:42
Pero no, lo particularizo para mi animal 00:17:45
Entonces diré que cuando gato hace y produce sonido 00:17:47
ahora system.auto.ptln 00:17:51
miau 00:17:54
y cuando hace el perro 00:17:54
el perro claramente 00:17:59
hace bau 00:18:00
vosotros si os equivocáis en España 00:18:02
decís que hace guau 00:18:04
pero no, hace bau 00:18:05
porque aquí 00:18:09
efectivamente 00:18:09
entendéis 00:18:13
es sutil la diferencia 00:18:15
pero hay una diferencia 00:18:17
yo puedo sobre escribir este método 00:18:19
en una clase redada 00:18:21
Para o extender 00:18:22
Lo que hacía antes, ahora hace algo más 00:18:25
¿Vale? 00:18:27
O cambiarlo completamente en base a que 00:18:28
Esta clase que hereda 00:18:31
Hace una funcionalidad un poquito distinta 00:18:32
¿Sí? 00:18:34
Si definimos en una subclase 00:18:36
Un método con la misma 00:18:40
Signature 00:18:42
Con la misma firma, ¿vale? 00:18:44
Nombre, tipo y número de parámetros 00:18:46
Que en la superclase 00:18:48
De la clase 00:18:50
El método de la superclase 00:18:51
queda oculto 00:18:54
es decir 00:18:56
si gato produce sonido 00:18:57
sin parámetros 00:19:00
y animal produce sonido 00:19:02
sin parámetros, ahora produce 00:19:04
sonido 00:19:06
de animal, se queda oculto 00:19:08
cuando yo tengo un gato, usaré el de gato 00:19:10
no el de 00:19:12
de animal 00:19:14
parecido 00:19:16
a los shadowing de antes 00:19:18
cuando declaraba una cosa en una clase 00:19:19
inferior, pues lo que está haciendo es ocultar lo de la clase superior. Entonces, si yo tengo 00:19:22
el método arrancar, estamos siempre en esta cosa de aquí, ¿vale? Y tenemos el método 00:19:29
arrancar. Si yo en coche uso arrancar, pues estoy usando el método de arrancar de coche. 00:19:35
Si uso dis.arrancar, estoy utilizando el método de coche. Si uso super.arrancar, voy a utilizar 00:19:42
el método del vehículo 00:19:50
el shadowing es sobre 00:19:52
parámetros, sobre atributos 00:20:03
y el overriding es sobre métodos 00:20:05
pero tiene una diferencia fundamental 00:20:07
que la veremos 00:20:09
ahora, fijaos que no puedo 00:20:11
usar super, super, punto nombre 00:20:16
¿vale? pero el problema 00:20:17
es que no puedo usar esto 00:20:20
es decir, que en una situación 00:20:22
como esta 00:20:27
desde coche, no puedo 00:20:28
usar arrancar de transporte 00:20:31
puedo llegar como 00:20:35
máximo a vehículo usando super punto arrancar 00:20:36
si quisiera llegar a transporte debería en vehículo 00:20:40
poner un método que hace super punto arrancar 00:20:44
entonces vehículo puede acceder a transporte y yo puedo acceder a vehículo 00:20:48
por lo tanto lo puedo hacer 00:20:52
pero no lo puedo hacer directamente, esto porque 00:20:54
cuando hago shadowing esta cosa de aquí funciona 00:20:59
Si yo le digo, o esta, si yo le digo this, tráctamelo como transporte, para él es un transporte, entonces accederá a esto. 00:21:04
Cuando uso el overriding, si yo hago this y lo casteo a otra cosa, a vehículo en este caso, no se usa el tipo de la referencia, 00:21:12
Entonces, no obstante la referencia sea transporte, porque la he casteado a transporte, y el objeto que he creado es un coche, y por lo tanto uso el de coche. 00:21:25
no se usa 00:21:40
no se usa 00:21:44
el tipo 00:21:57
de la referencia 00:21:58
mas se usa el tipo 00:22:01
del objeto 00:22:03
de la instancia 00:22:05
en el shadowing 00:22:10
el tipo de la referencia cuenta 00:22:13
en el overriding 00:22:15
overriding 00:22:18
no se 00:22:19
se usa 00:22:19
el tipo de la instancia 00:22:22
queda claro 00:22:25
o sea que si yo hago 00:22:28
a.arrancar 00:22:33
o bueno aquí es alumno 00:22:35
si yo hago a.saludar 00:22:37
o p.saludar 00:22:40
siempre estaría utilizando 00:22:43
la implementación de saludar 00:22:46
de la clase alumno 00:22:47
porque esto es un alumno 00:22:49
entonces es normal que use el de alumno 00:22:53
pero esto debería ser una persona 00:22:56
pero Java se da cuenta que no obstante 00:22:58
tú lo estés llamando con una referencia 00:23:01
de tipo persona, en realidad 00:23:03
esto no es una persona, este es un 00:23:05
alumno, y entonces te va 00:23:07
a utilizar los métodos de la clase 00:23:09
más específica, queda claro 00:23:11
esta es la diferencia entre shadowing 00:23:17
y además que une sobre 00:23:21
parámetros y une sobre métodos 00:23:23
funcionan un poquito 00:23:26
distinto, si entonces por ejemplo 00:23:27
en overriding, yo aquí tenía recurso 00:23:31
tenía decir descripción, ahora 00:23:33
decir descripción vale para 00:23:35
todo, pero por ejemplo la descripción de un aula 00:23:37
o de un ordenador son distintos 00:23:39
pues entonces aquí 00:23:41
sobrescribo decir descripción 00:23:43
esto quiere decir que cuando 00:23:46
desde aquí uso this.decir 00:23:47
descripción estoy usando 00:23:50
esta definición 00:23:51
si desde aula uso 00:23:53
super.decir descripción 00:23:55
estoy usando el método de 00:23:57
recurso, ¿se entiende? 00:23:59
al mandar un mensaje a un objeto 00:24:03
el método seleccionado 00:24:08
depende de la clase real 00:24:10
del objeto, del que el objeto es 00:24:12
una instancia, lo que decimos ahora 00:24:14
si yo llamo 00:24:16
el decir descripción 00:24:19
y no sé si voy a utilizar 00:24:20
el de recurso o el de aula 00:24:22
no voy a mirar el tipo de la variable 00:24:24
sino voy a mirar 00:24:27
el tipo de la instancia 00:24:28
¿dónde se define el tipo de la instancia? 00:24:30
¿dónde se define el tipo de la instancia? 00:24:39
¿Vosotros queréis ser programadores en la vida o queréis ser gente que mira cosas al azar? 00:24:40
Pues, ¿dónde se define qué tipo tiene el objeto que creo? 00:24:59
¿En qué parte del código? 00:25:07
¡Exacto! En la new 00:25:12
Cuando yo hago new cocodrilo 00:25:13
Estoy creando un objeto de tipo cocodrilo 00:25:17
En la instancia de tipo cocodrilo 00:25:21
Ahora, luego este cocodrilo lo puedo guardar en otra cosa 00:25:22
No, es una instancia de cocodrilo 00:25:26
Pero la referencia es de otro tipo 00:25:33
Si yo hago persona p 00:25:35
Es igual a new alumno 00:25:37
Lo puedo hacer 00:25:38
Porque alumno es una persona 00:25:39
La referencia es persona 00:25:43
Pero la instancia 00:25:47
Sigue siendo un alumno 00:25:49
En un cierto sentido es lo que ha hecho aquí 00:25:50
¿Dónde estaba? 00:25:52
Aquí 00:25:55
Yo he creado un nuevo alumno 00:25:56
Esto es un alumno 00:25:59
Pero luego he creado una referencia 00:26:01
Que no tiene el mismo tipo 00:26:03
Pero tiene un tipo compatible 00:26:04
Yes 00:26:06
¿Y si dejara la instancia de persona? 00:26:10
Probablemente también 00:26:17
Porque el alumno tiene dentro una instancia de persona 00:26:18
¿Sí? 00:26:24
Vale, estamos acabando 00:26:32
Casi 00:26:33
Entonces 00:26:35
Ejemplo de overriding 00:26:40
No lo sé como se dice 00:26:42
Aquí tengo persona 00:26:43
con imprimir, aquí tengo alumno 00:26:46
que extiende personas con imprimir 00:26:49
fijaos que esto, el cambio aquí 00:26:51
es simplemente que esto escribe persona y esto escribe alumno 00:26:52
¿vale? 00:26:55
si yo uso 00:26:56
alumno A es igual a null alumno 00:26:58
persona P es igual a A, lo que hemos 00:27:00
hecho antes, y luego llamo A.imprimir 00:27:02
o P.imprimir 00:27:05
los dos me escriben 00:27:06
alumno 00:27:08
esto, porque es obvio 00:27:09
este aquí es menos obvio, pero 00:27:12
él va a mirar P, ve que 00:27:14
p apunta a una instancia de tipo alumno y entonces 00:27:16
decide de utilizar el imprimir de alumno, no el imprimir de persona 00:27:20
¿si? y tiene sentido, lo veremos con polimorfismo 00:27:24
y cosas por el estilo, que tiene sentido que funcione así 00:27:33
super, vale, y son 3, 4, 3, 3, 3 00:27:35
super es una referencia al objeto actual como si fuera una instancia 00:27:42
de la superclase, vale, lo hemos visto aquí, cuando yo hago 00:27:47
SuperPuntaArrancar 00:27:51
Estoy diciendo, oye mira 00:27:54
Voy a utilizar este objeto 00:27:56
Pero no como si fuera de esta clase 00:27:58
Como si fuera de la clase superior 00:28:00
Entonces cuando llamo 00:28:02
SuperPuntaArrancar 00:28:04
Voy a usar el método arrancar 00:28:05
De mi superclase 00:28:08
O sea en este caso de vehículo 00:28:09
Aquí 00:28:11
A través de la referencia super 00:28:15
Se puede acceder específicamente 00:28:17
A métodos de la superclase 00:28:19
o a variables 00:28:21
de la superclase si tienen 00:28:23
shadowing, vale, lo hemos visto 00:28:25
antes, yo tenía nombre, dis.nombre 00:28:27
me daba una cosa, si pero 00:28:29
usaba super.nombre 00:28:31
iba a mi padre 00:28:32
o sea, iba 00:28:34
al valor que le había dado a esa 00:28:35
variable como si fuera 00:28:39
una clase de tipo superclase 00:28:40
para reescribir métodos 00:28:43
no solo el constructor 00:28:46
puede ser útil usar la referencia super, ¿vale? 00:28:48
¿Os acordáis? Antes decíamos, yo podría hacer 00:28:52
todo lo que hace, un método que hace todo lo que hace el método 00:28:56
de mi superclase y algo más. Como 00:29:00
me voy a presentar y digo, hola, soy Estefano, y luego 00:29:03
poner todas mis notas, porque soy un alumno. 00:29:07
¿Os acordáis? Pues, la parte de escribir 00:29:13
Hola soy Stefano, ya la tengo, la tengo en persona 00:29:16
Entonces lo que puedo hacer es, vale, mi método imprime de alumno es 00:29:19
Haz todo lo que hacía la clase superior, super.imprime 00:29:24
Llama el método de arriba, entonces se escribirá ya Hola soy Stefano 00:29:29
Y a continuación sigues con las cosas nuevas, ¿se entiende? 00:29:34
En este caso este super no es necesario utilizarlo como primera línea del método 00:29:41
Se puede usar cuando te da la gana, lo puedes usar hasta dos veces 00:29:53
Entonces para resumir de super, super se puede utilizar así o así 00:29:56
Para hacer referencia a un constructor 00:30:05
Y que este de aquí 00:30:09
Si no pongo nada 00:30:13
Se llama implícitamente 00:30:14
Puede usar super como referencia 00:30:15
Parecido al dis 00:30:20
A un método 00:30:22
O a un atributo 00:30:23
Que sería, usa este método 00:30:25
Usa este atributo 00:30:27
Como si fuera yo 00:30:29
Un objeto de mi superclase 00:30:31
Y luego está esta cosa 00:30:33
del instanceOf. Como ahora tengo el caos 00:30:45
porque puedo tener variables que no sé dentro si tienen 00:30:49
un alumno, una persona, un empleado o lo que sea, tengo 00:30:53
este mecanismo de aquí, que sostancialmente 00:30:57
le digo una variable instanceOf una clase 00:31:01
y él me devuelve true si este 00:31:05
señor es una instancia de este de aquí o false si este 00:31:09
no es. Aquí error, pero en realidad 00:31:13
sí es false. 00:31:15
Entonces, si yo hago gato, gato es igual a new gato. 00:31:16
Y luego le pregunto, ¿gato es un animal? 00:31:19
Sí, porque 00:31:21
gato hereda de animal. 00:31:23
Entonces, gato es un animal. 00:31:25
¿Gato es un gato? 00:31:27
Sí, porque gato es un gato. 00:31:29
Pero si le digo, ¿gato es un perro? 00:31:31
No. Con esto 00:31:33
puedo saber 00:31:38
una variable, qué tipo 00:31:39
es, y en base a eso 00:31:42
poder hacer casting, etc. 00:31:43
Vale 00:31:46
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
12
Fecha:
14 de enero de 2025 - 12:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 50″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
88.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid