Saltar navegación

20260114 Herencia_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 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

y situarnos 00:00:00
bueno pues 00:00:01
recordad que esto de la herencia 00:00:04
era simplemente 00:00:06
una relación 00:00:07
que se podía establecer entre dos 00:00:10
entidades cuando una 00:00:12
es un caso particular de la otra 00:00:14
entonces 00:00:16
si identificamos esa relación 00:00:18
de herencia entre dos entidades 00:00:20
eso si queremos 00:00:22
puede tener implicaciones en nuestro 00:00:24
código 00:00:26
podemos ignorar todas las relaciones 00:00:27
pero si ignoramos todas las relaciones 00:00:30
las aplicaciones van a quedar infinitamente más complicadas 00:00:33
de desarrollar, entonces si no las ignoramos 00:00:36
la aplicación va a quedar un poquito más manejable 00:00:39
entonces la relación de herencia es la relación en la cual 00:00:42
identificamos que una entidad es un caso particular de otro 00:00:45
y en ese caso a la hora de programarlo 00:00:48
lo que hacíamos era 00:00:51
pues poner el extends 00:00:53
y ya sabemos lo que significa entonces 00:00:55
que todo lo que 00:00:59
está en cliente, tanto propiedades 00:01:01
como métodos 00:01:04
automáticamente aparece 00:01:05
en un copia y pega en esta 00:01:07
otra, aparece en un copia y pega 00:01:09
sin que hagamos nada, constructores no 00:01:11
ahora los incorporamos, los constructores no 00:01:13
aparece como un copia y pega 00:01:15
bueno, entonces es una manera de reutilizar 00:01:16
código, pero bueno 00:01:19
no es por esto 00:01:21
por lo que se hace la herencia en realidad 00:01:22
No es la mejor manera de reutilizar código, en realidad. Por lo que se hace la herencia es para poder generalizar y tratar a objetos de diferentes clases, tratarlos de una manera común. 00:01:25
¿Vale? No tener que hacer métodos específicos para cada entidad, porque si todos comparten algo, todos los clientes, cliente VIP, cliente moroso, cliente no sé qué, todos comparten algo, en este caso que son clientes, pues los puedo tratar a todos por igual en algunas cosas. 00:01:38
entonces esa sí es la verdadera ventaja de la herencia 00:02:00
entonces ¿en qué se traduce? 00:02:03
pues el ejemplo que pusimos aquí en el main 00:02:06
pues vimos cómo efectivamente 00:02:08
en una referencia de tipo cliente 00:02:10
aquí en una raya además 00:02:13
se puede guardar cualquier tipo de cliente 00:02:16
yo tengo una colección entera 00:02:19
y puedo tener clientes de diferentes tipos en esa colección 00:02:22
en este método 00:02:25
este método, que hacíamos un método aquí 00:02:30
dentro de mi main, en el que 00:02:32
yo decía, oye voy a mostrar los datos 00:02:34
de un cliente 00:02:36
entonces, aquí este método 00:02:38
es un método que yo hago único 00:02:40
para cualquier cliente, me da 00:02:42
igual, este método es único para cualquier 00:02:44
cliente, entonces 00:02:46
le paso como parámetro, efectivamente 00:02:48
un objeto, cliente 00:02:51
pero luego ya en tiempo de ejecución 00:02:52
cuando yo llame a este método 00:02:54
y ya sí que le pase una instancia 00:02:56
lógicamente ya sí que le pasamos una instancia 00:02:58
pues ahora ya 00:03:00
el método trabaja con esa 00:03:02
instancia en particular y esa instancia 00:03:04
puede ser cualquier heredera 00:03:06
de aquí, cualquiera 00:03:08
heredera en primera instancia 00:03:10
o heredera nieta, da igual 00:03:12
entonces 00:03:14
esto nos permitió incorporar 00:03:17
el instance of este de aquí 00:03:20
que es 00:03:22
en tiempo de desarrollo de código 00:03:27
en tiempo de desarrollo de código 00:03:29
yo sé que 00:03:32
esto es un cliente 00:03:34
¿vale? 00:03:37
y puede ser además de un cliente cualquiera 00:03:38
de sus subclases, cualquiera de sus implementaciones 00:03:41
y claro, en función de la subclase 00:03:42
que sea, yo quiero hacer una cosa 00:03:45
o quiero hacer otra 00:03:46
bueno, pues este operador 00:03:47
este operador es el que nos permite 00:03:50
averiguar 00:03:53
cómo se ha instanciado 00:03:54
un objeto 00:03:56
el objeto C está declarado como cliente 00:03:57
está declarado como cliente 00:04:01
pero se puede haber instanciado 00:04:03
con new cliente 00:04:06
se puede haber instanciado 00:04:07
con new cliente no sé cuál 00:04:09
se puede haber instanciado de mil maneras distintas 00:04:10
yo no lo sé 00:04:12
cualquiera de ellas puede inyectarse aquí 00:04:14
puede inyectarse aquí 00:04:17
en esta referencia 00:04:19
bueno si yo necesito saber 00:04:20
cuál de las variantes es 00:04:23
que lo más normal es que necesites 00:04:25
saberlo para que el método 00:04:27
trate de forma 00:04:30
diferenciada a cada 00:04:31
tipo de objeto. Pues si 00:04:33
necesito saber qué tipo de 00:04:35
objeto es este de aquí, 00:04:37
pues tengo este operador. 00:04:40
¿Vale? Que funciona 00:04:42
de esta manera. Objeto, 00:04:43
nombre de una clase, 00:04:45
nombre de una clase, devuelve 00:04:47
true si se ha instanciado 00:04:49
como esta clase o false si no. 00:04:51
¿Vale? Bueno, pues esto 00:04:54
sería una manera 00:04:59
de que a través de un único método 00:05:00
con lo cual haciendo nuestro código 00:05:03
mucho más claro, tratar objetos 00:05:04
de diferentes tipos, a través 00:05:06
de mostrar datos cliente 00:05:08
pues yo puedo 00:05:10
mostrar datos de un cliente VIP 00:05:12
de un cliente moroso, de un cliente 00:05:14
no sé cuántos, a través de un único dato 00:05:16
a través de un único método, mostrar datos 00:05:18
clientes, entonces ser unificado 00:05:21
sea lo que queráis 00:05:23
¿vale? pero hay otra 00:05:23
manera, otro diseño 00:05:26
otra filosofía, esto es todo cuestiones de diseño 00:05:29
no es 00:05:31
todas las diferentes alternativas que tenemos 00:05:31
para diseñar 00:05:34
no es tanto lo que está bien y lo que está mal 00:05:35
pues hay otra alternativa de diseño 00:05:38
para tratar 00:05:41
a las diferentes subclases de forma 00:05:44
diferenciada, pero todas 00:05:47
bajo un mismo nombre 00:05:48
de método, que es la idea, bajo un mismo 00:05:50
nombre de método, en realidad 00:05:53
estoy haciendo cosas distintas 00:05:54
dependiendo del objeto en el que esté 00:05:57
que es la idea 00:05:58
pues hay otra forma que es 00:05:59
mediante la implementación 00:06:02
de lo que se llama el polimorfismo 00:06:04
entonces el polimorfismo 00:06:06
es el concepto que siempre 00:06:13
aparece cuando se habla de la programación 00:06:15
orientada a objetos y en particular 00:06:17
de la herencia 00:06:18
polimorfismo significa 00:06:19
adoptar muchas formas 00:06:22
evidentemente, esa es la traducción de la palabra 00:06:24
algo polimorfo adopta 00:06:27
muchas formas 00:06:29
bueno pues 00:06:29
este método 00:06:31
uno podría decir 00:06:33
este método 00:06:34
es polimorfo 00:06:35
porque 00:06:36
el cliente 00:06:38
es de cliente VIP 00:06:40
hace esta línea 00:06:41
de código 00:06:43
si el cliente 00:06:44
no es cliente VIP 00:06:46
no hace esta línea 00:06:47
de código 00:06:48
entonces 00:06:49
hombre no puede interpretar 00:06:50
que es polimorfo 00:06:51
pero a ver 00:06:52
no es exactamente 00:06:53
este el significado 00:06:54
de polimorfismo 00:06:55
sino la que vamos 00:06:55
a ver ahora 00:06:58
vale 00:06:58
pues bueno, una alternativa 00:07:00
para poder mostrar los datos del cliente 00:07:02
de forma diferenciada 00:07:05
en función del cliente que sea 00:07:07
una alternativa a esta 00:07:09
pues 00:07:10
vamos a volver a nuestro diseño de cliente 00:07:11
y cliente normal 00:07:15
vale, pues como este método 00:07:15
mostrar datos cliente 00:07:18
con quien trabaja, con un cliente 00:07:20
para mostrar sus datos 00:07:23
luego yo lo he ubicado aquí 00:07:24
lo he ubicado aquí en mi main 00:07:26
recordad que este método estaba en el main 00:07:28
estaba en el main 00:07:30
entonces me he hecho un método auxiliar 00:07:33
mostrar datos cliente 00:07:35
al que le tengo que pasar el cliente 00:07:38
y así he tirado 00:07:40
con mi aplicación y podría seguir así hasta el 00:07:42
infinito de mi aplicación 00:07:44
pero hombre, este diseño 00:07:45
es bastante feo 00:07:47
porque 00:07:49
primero, mete muchas cosas en la clase main 00:07:50
la clase main 00:07:54
tiene que hacer lo menos posible 00:07:55
Y segundo, esto de aquí, ¿con quién trabaja? Con un cliente, ya está. Pues entonces, si esto de aquí trabaja con un cliente, eso es un comportamiento del objeto cliente, luego eso debería ir en la clase cliente, ¿vale? 00:07:58
es decir, mostrar 00:08:15
un cliente sus datos es una cosa 00:08:17
que hace un objeto cliente 00:08:20
bueno, pues entonces las cosas 00:08:22
que hacen los objetos, lo normal 00:08:24
es que se declaren en las clases 00:08:26
de esos objetos 00:08:28
entonces aquí está como metido 00:08:29
un poco a calzador este método 00:08:32
claro, uno arranca la aplicación 00:08:33
y puede tirar con ella hasta donde llegue 00:08:36
pero hombre 00:08:38
la idea es seguir ciertas pautas 00:08:40
de diseño, entonces 00:08:42
Pues idealmente, si mi aplicación va a necesitar que se muestren los datos de los clientes, pues donde lo colocaríamos aquí, ¿vale? Era un poco lo que cuando empezamos con clases objeto, o sea, lo que decíamos. Las clases tienen propiedades y comportamientos, que es lo que el objeto me interesa que haga en la aplicación. 00:08:44
pues aquí en la aplicación voy a necesitar 00:09:05
que el objeto cliente muestre sus datos 00:09:08
lo voy a necesitar, pues metámoslo aquí en la clase cliente 00:09:11
pues nada, aquí meteríamos 00:09:15
un método cualquiera 00:09:17
mostrar datos 00:09:22
lógicamente no le pasaríamos nada 00:09:25
como parámetro, nada 00:09:30
porque este método ya accede a todas las propiedades del objeto 00:09:32
luego no necesita que le pasemos nada 00:09:37
Pues magnífico 00:09:39
Soy un 00:09:48
Para que no sea un toString estándar 00:09:49
Soy el cliente 00:09:54
Nombre 00:09:57
Y minifest 00:10:06
Vale 00:10:13
Esto desde no sé qué versión 00:10:15
Creo que lo hemos usado alguna vez 00:10:24
Puedes hacer un stream multilínea así 00:10:25
¿No? 00:10:28
Y hasta que no 00:10:29
pero cuando 00:10:31
¿qué pasa? pero cuando lo rompes 00:10:33
con el más, no me acuerdo 00:10:35
como quedaba 00:10:37
ya, ya sé que tiene que estar al principio y al final 00:10:38
pero el tema es cuando estás rompiendo 00:10:43
el string para concatenarle cosas 00:10:45
entre medias 00:10:47
entonces no 00:10:48
ya, pero 00:10:49
bueno 00:10:52
estás hablando con los expertos de la triple comilla 00:10:54
no saben hacer otra cosa, no saben hacer un array 00:10:56
pero saben hacer triple comillas 00:10:59
bueno, a ver 00:11:00
si estos detallitos os gustan 00:11:04
jugar con ellos, yo para los detallitos 00:11:06
normalmente los paso por alto 00:11:09
no me dan igual 00:11:10
aquí era por si quedaba muy largo 00:11:11
pero vamos 00:11:14
esos detallitos ya 00:11:16
ya es un tema vuestro, no es lo que me 00:11:17
importa a mi, vale 00:11:20
bueno 00:11:21
vale, pues ya tendríamos el método mostrar datos 00:11:23
vale, muy bien, entonces 00:11:28
¿qué hemos ganado poniendo aquí el método 00:11:30
de mostrar datos? Pues lógicamente 00:11:32
que desde mi main 00:11:34
ahora ya este método que se queda aquí 00:11:35
pues 00:11:38
paso de él 00:11:39
¿qué hemos ganado yo ahora 00:11:42
con mi método de mostrar datos? Pues que 00:11:44
ahora cualquier cliente creado puede mostrar 00:11:46
datos, ¿verdad? Por ejemplo, este C3 00:11:48
puede aquí 00:11:50
mostrar sus datos 00:11:52
vale, este objeto C3 que está 00:11:54
sin instanciar, por eso no 00:11:56
a ver, voy a poner aquí arriba 00:11:58
Por ejemplo, este era mi main que estaba haciendo de pruebas 00:12:00
Tengo mi cliente C1 00:12:04
Pues mi cliente C1 puede mostrar sus datos 00:12:05
¿Vale? 00:12:08
Entonces, bueno, este diseño es mejor 00:12:10
Que no llamar al método 00:12:12
Mostrar datos cliente 00:12:15
Y pasarle el objeto C 00:12:18
Mostrar datos cliente y pasarle C 00:12:21
en realidad estoy haciendo 00:12:25
lo mismo con los dos diseños 00:12:28
¿verdad? 00:12:30
con este estoy llamando al método auxiliar 00:12:31
que está en el mail 00:12:34
con este estoy llamando al método 00:12:35
que está en la clase cliente 00:12:37
¿vale? 00:12:39
pero 00:12:41
pero 00:12:42
esto 00:12:43
feo, muy mal, caca 00:12:49
y esto bien 00:12:52
esto mal, esto bien 00:12:53
¿por qué esto mal? 00:12:55
mal en cuanto a 00:12:59
conceptualmente 00:13:01
porque estoy metiendo 00:13:02
aspectos de mi negocio 00:13:04
en la clase 00:13:07
main, no 00:13:09
el cliente 00:13:10
se caracteriza y su comportamiento es un tema 00:13:12
ya de mi negocio y lo tengo que ubicar en cliente 00:13:14
si yo ahora hago cualquier cambio 00:13:17
en mis clientes 00:13:19
yo me voy 00:13:20
a mi diseño de clases y me voy 00:13:22
a cliente y ahí lo encuentro 00:13:25
y mi main no tiene ni que enterarse 00:13:26
con este diseño de aquí abajo 00:13:28
de aquí abajo, mostrar datos 00:13:30
clientes, está como 00:13:32
método auxiliar dentro del main 00:13:35
no está en cliente, entonces si yo 00:13:36
hago cualquier cambio con los clientes 00:13:39
no es a la clase cliente 00:13:40
donde me tengo que ir, sino a la clase main 00:13:43
ya ves tú que tendrá que ver la clase main con los clientes 00:13:45
¿vale? 00:13:47
bueno, eso en cuanto a pequeñas pautas de diseño 00:13:49
¿vale? pero ahora, a lo que íbamos 00:13:51
Yo ahora he puesto aquí ya mi método mostrar datos dentro de cliente. Vale, como cliente VIP hereda de cliente, hereda, este método mostrar datos que yo he puesto aquí, este método tal cual está en cliente VIP, aunque yo no lo escriba, tal cual. 00:13:53
Ahí está ese, aunque yo no lo toque 00:14:17
Aunque yo no lo escriba 00:14:20
Ese está tal cual 00:14:21
¿Qué significa eso? 00:14:23
Que yo ahora me he hecho mi cliente VIP 00:14:26
Y yo ahora mi cliente VIP C2 00:14:28
También puede llamar a mostrar datos 00:14:32
Y ningún problema 00:14:34
C2 es de la clase 00:14:37
Cliente VIP 00:14:39
Y puede llamar a mostrar datos 00:14:39
Porque mostrar datos está aquí 00:14:42
Aunque yo no lo vea físicamente 00:14:44
Porque se ha hecho un copia y pega de este 00:14:46
Hasta ahí vale, ¿no? 00:14:48
Y si uno ejecuta esto, pues efectivamente 00:14:52
Aparecerán los datos de los dos 00:14:55
¿Vale? 00:15:00
Esta es la llamada del cliente normal C1 00:15:03
Y esta es la llamada del cliente VIP C2 00:15:06
¿Pero no ha hecho como el cliente? 00:15:10
Claro, porque ha heredado el método 00:15:12
Y el método dice esto 00:15:14
Ah, vale 00:15:15
Ahora viene esa pregunta, es Jolín 00:15:16
Pues esta es una herencia 00:15:19
que no me interesa nada 00:15:20
diría el cliente VIP 00:15:22
estoy heredando un método 00:15:24
que no me gusta 00:15:26
porque sí, está mostrando mi parte común 00:15:28
que es ni fin hombre, pero hombre 00:15:30
yo soy un cliente VIP 00:15:32
y lo que estoy 00:15:34
heredando de ti, pues no me gusta 00:15:36
querría darle otra 00:15:38
forma, pues ahí viene 00:15:40
el polimorfismo, que es 00:15:42
lo que yo heredo, lo puedo 00:15:44
dejar tal cual, o lo puedo 00:15:46
cambiar, lo puedo 00:15:48
reescribir de nuevas, le puedo dar otra forma 00:15:50
de ahí viene el nombre de polimorfismo, entonces cliente VIP dice 00:15:53
a ver, los getter y los setter que le he dado me encantan 00:15:58
pero mostrar datos no me gusta, pues lo sobrescribo 00:16:01
y sobrescribirlo implica 00:16:06
hacerlo enterito de nuevas otra vez, no es 00:16:09
añado lo nuevo, no, no, no, lo tengo que escribir 00:16:14
de nuevas, con la misma 00:16:18
cabecera 00:16:20
tal cual 00:16:21
este ya, el heredado 00:16:23
ha desaparecido 00:16:26
el heredado ha desaparecido completamente 00:16:27
yo lo escribo 00:16:29
de nuevas y en este caso haría, ahora soy cliente 00:16:32
aquí nombre 00:16:34
no lo ve, es normal que no lo vea 00:16:35
porque 00:16:38
está 00:16:39
aquí como privado, vale 00:16:40
bueno, ahora esto lo digo ahora 00:16:44
Porque no es trivial 00:16:49
Vale, entonces, ¿qué añadiría esto? 00:16:49
O sea, sniff y este método querríamos que 00:16:52
Ahora corregimos ese rojo 00:16:58
Y además querríamos 00:16:59
Y mi dirección es dirección 00:17:02
Vale, ahora corregimos ese rojo 00:17:14
Vamos ahora a la sobrescritura 00:17:18
Bueno, pues esto es sobrescribir en un método, que es coger ese método con esa cabecera y darle otro cuerpo completo. 00:17:21
Entonces, desde el momento que en la clase heredera aparece un método con el mismo nombre cabecera que el de la superclase, 00:17:30
el de la superclase ya desaparece, ¿vale? Ya desaparece y este es el sobrescrito. 00:17:39
¿vale? pues este es el polimorfismo 00:17:44
es decir, el método se llama igual 00:17:48
mostrar datos, en ambos casos 00:17:51
pero depende de quien lo llame 00:17:54
adopta una forma u otra 00:17:56
aquí en este main 00:17:58
tendríamos 00:18:00
C1 mostrar datos 00:18:03
y C2 mostrar datos 00:18:06
¿vale? 00:18:08
luego las llamadas son idénticas 00:18:12
las llamadas son iguales 00:18:14
Los dos llaman a mostrar datos, pero la versión del método a la que llaman es diferente. 00:18:15
C1, ¿a qué versión llama? 00:18:21
Pues llama a la versión suya tal y como se ha instanciado. 00:18:23
¿Tú cómo te has instanciado? Como cliente. 00:18:28
Entonces, como tú te has instanciado como cliente, tú llamas a esta versión de cliente. 00:18:31
Llamas a esta. 00:18:37
Aquí, C2, ¿tú cómo te has instanciado? 00:18:40
Tú te has instanciado como cliente VIP. 00:18:44
Entonces como tú te has instanciado como cliente VIP 00:18:46
Tú llamas a esta 00:18:50
Ahora le corregimos eso 00:18:52
Tú llamas a esta 00:18:54
Luego por eso este método es polimórfico 00:18:55
Porque adopta una forma o adopta otra 00:18:59
En función de cómo se ha instanciado ese objeto 00:19:01
¿Vale? 00:19:05
Cómo se ha instanciado 00:19:07
No cómo se ha declarado 00:19:08
Cómo se ha instanciado 00:19:10
¿Vale? 00:19:11
Porque cliente el C2 este 00:19:15
el C2 podría yo haberlo declarado 00:19:18
así, no hay ningún problema 00:19:21
¿verdad? voy a quitar esto para que 00:19:22
podría haberlo declarado así, voy a poner el casting 00:19:25
para que no se queje, claro 00:19:28
vale 00:19:30
vale, podría yo haberlo 00:19:32
declarado como cliente ¿verdad? 00:19:35
no hay ningún problema, ya sabemos que yo luego 00:19:37
lo instancio como cualquiera de las subclases 00:19:38
vale, si yo lo declaro 00:19:40
como cliente 00:19:43
la versión de mostrar 00:19:44
datos a la que se llama 00:19:47
esa la de cliente, no 00:19:48
siempre se llama 00:19:50
a la correspondiente a como se instanció 00:19:52
vale 00:19:55
siempre, vale 00:19:57
la versión a la que se llama 00:20:06
corresponde 00:20:07
a la de la 00:20:09
instanciación, no a la de la creación 00:20:11
declaración, perdón, instancia 00:20:13
acción 00:20:15
es decir 00:20:17
me da igual que C2 00:20:20
se haya 00:20:21
declarado como 00:20:22
cliente, se ha declarado como 00:20:25
cliente, pero se ha construido 00:20:27
se ha instanciado como cliente VIP 00:20:28
luego la versión a la que se llama 00:20:30
es a la de la instanciación 00:20:33
¿vale? 00:20:35
pues este es el polimorfismo 00:20:37
o sea, esa 00:20:39
llama a la de cliente 00:20:46
entonces 00:20:48
este de aquí llama a la de cliente 00:20:48
porque está creado como new cliente 00:20:51
y esta llama 00:20:54
a la de 00:20:55
cliente VIP, porque está 00:20:57
creado como new cliente VIP 00:20:59
tal y como esté 00:21:01
creado, esa es a la que llama 00:21:03
y tiene sentido 00:21:05
tiene sentido, lo que importa 00:21:07
es tú que eres un cliente VIP 00:21:09
pues tu comportamiento tiene que ser 00:21:11
en tiempo de ejecución, tu comportamiento tiene que ser 00:21:13
el de cliente VIP, depende de lo que tú eras 00:21:15
claro, pero 00:21:17
porque aquí estamos en tiempo de escritura de código 00:21:21
que es un tiempo diferente al de ejecución 00:21:23
el tiempo de escritura de código 00:21:24
es el de las reglas, el de la sintaxis 00:21:27
el de hacerle 00:21:29
el de 00:21:31
respetar lo que el compilador te obliga 00:21:32
a hacer para prever 00:21:35
la mayoría de los errores posibles 00:21:37
entonces en tiempo de escritura de código 00:21:38
tú pones C2 en dirección 00:21:40
el compilador te dice 00:21:43
a ver, C2 está declarado como cliente 00:21:45
porque puede no tener 00:21:47
acceso como está instanciado 00:21:49
de hecho, aquí 00:21:51
¿por qué ocurre eso? porque él mira como se ha 00:21:53
declarado. Porque en muchas situaciones 00:21:55
no tiene acceso a cómo se ha instanciado. 00:21:57
Aquí el compilador 00:21:59
cuando hagamos... Aquí no podríamos hacer 00:22:03
C.dirección 00:22:05
porque, claro, el compilador 00:22:07
no puede saber. 00:22:09
Es imposible. No puede saber cómo se instanció 00:22:11
este. No puede saberlo. 00:22:13
¿Esto cómo se habrá 00:22:16
instanciado? Eso ya dependerá del main que llame 00:22:17
a este. Ese main a saber dónde estará. 00:22:19
No está en este fichero. 00:22:21
no está, entonces el compilador 00:22:22
tiene que mirar la clase 00:22:24
como se ha declarado, pero eso es 00:22:26
el compilador, en tiempo de escritura 00:22:28
de código, entonces el compilador 00:22:31
verifica, vale 00:22:33
C punto no sé qué, esto está en cliente 00:22:34
bien, C punto 00:22:36
que es dirección, esto está en cliente 00:22:38
no, no te dejo ponerlo porque no está en cliente 00:22:40
pero si tú sabes 00:22:43
si tú sabes 00:22:45
que C en realidad 00:22:46
es una instancia de cliente VIP 00:22:48
pues te haces el casting 00:22:50
y solucionas 00:22:51
y haces la 00:22:53
trampa, no es trampa, porque es que 00:22:54
tiene todo el sentido de los diseños y así 00:22:57
vale 00:22:59
entonces el compilador sigue sus reglas 00:23:00
ahora de escribir código 00:23:03
pero esto ya es otra situación 00:23:04
aquí estamos ya llamando a métodos 00:23:06
esto es tiempo de ejecución 00:23:10
aquí estamos llamando 00:23:12
aquí estamos ya llamando 00:23:13
esto es tiempo de ejecución 00:23:16
llamo a este método, llamo a este método 00:23:17
y en tiempo de ejecución 00:23:19
Cuando yo ya llamo a métodos, no estoy declarando cosas, cuando yo ya llamo a métodos en tiempo de ejecución, el método que se elige depende de quién eres tú, de cómo te creaste, ¿vale? 00:23:21
Bueno, ¿entendido esto? 00:23:39
Sí, ahora lo arreglamos, sí, sí, lo que me importa es el concepto de, ¿vale? Por eso digo, ¿entendido? 00:23:51
Bueno, pues ahora para poder ejecutar esto 00:23:56
Vamos a arreglar esa cosa roja 00:23:59
Vale, a ver 00:24:00
Este método de aquí 00:24:02
A la hora de escribir aquí 00:24:03
La propiedad de acceso a nombre y a NIF 00:24:06
Dentro de cliente VIP 00:24:08
Que es donde estoy 00:24:10
¿Veis? No me ha dejado 00:24:11
Y diríamos, pero ¿cómo es que no te deja? 00:24:13
Si nombre y NIF 00:24:16
Lo ha heredado de cliente 00:24:18
Con lo cual es como hacer un copia y pega 00:24:21
¿Vale? 00:24:23
Yo con lo que he dicho hasta ahora 00:24:24
perdona, si cliente VIP hereda de cliente 00:24:26
estás haciendo un copia y pega de todo 00:24:28
salvo de los constructores 00:24:30
sí, pero cuidado 00:24:32
porque los modificadores de acceso son muy puñeteros 00:24:35
sí que estás haciendo un copia y pega 00:24:37
en el sentido de que 00:24:40
si cliente VIP hereda de cliente 00:24:41
en cliente VIP hay un nombre y un NIF 00:24:43
eso es impepinable 00:24:46
hay un nombre y un NIF 00:24:48
pero, puñetera mala suerte 00:24:49
como cliente les puso el private adelante 00:24:51
que es como debería 00:24:54
el compilador 00:24:55
las hace inaccesibles 00:24:58
desde cualquier parte 00:25:00
que no sea esta clase, incluso 00:25:02
desde las herederas 00:25:04
lo cual se genera una situación absurda 00:25:05
se genera una situación absurda 00:25:08
porque cliente VIP tiene su propiedad 00:25:10
nombre y su propiedad NIF 00:25:12
pero no podemos hacer referencia 00:25:14
a ellas porque estamos fuera de la clase cliente 00:25:16
vale, pues como se soluciona esto 00:25:19
hay dos posibilidades 00:25:22
posibilidades una tirar del get vale podríamos tirar del get y ya está porque el get sí que es 00:25:24
public lo tengo heredado por supuesto como todo y además como es public arriba vale esa es una 00:25:35
manera lo que pasa es que bueno esto quizás es un poco más feo porque dependo que la clase de 00:25:47
arriba tenga get y set que los tendrá que tener porque hacer unas propiedades privadas y no hacer 00:25:54
Pero bueno, dependo 00:25:59
Ah, ya decía yo que no se me movía esto 00:26:01
Vale, a ver 00:26:03
Bueno, pues ahora sí que sí necesito 00:26:06
A ver 00:26:09
Dime 00:26:20
¿Cómo? 00:26:52
Porque no tendrías private 00:27:01
En las propiedades de cliente 00:27:02
¿Y este por qué se ha ido? 00:27:05
Porque no me dice que esté cargando 00:27:29
vale, a ver 00:34:51
dime 00:34:52
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
14 de enero de 2026 - 14:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
112.21 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid