Saltar navegación

20260112 Herencia_2 - 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 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, el proyecto hecho, pues venga, voy a hacer un paquete para trabajar siempre en paquetes, pues yo que sé, cualquiera, pues venga, mi paquete, entonces resulta que yo aquí tengo mi clase cliente, estoy en un proyecto nuevo solamente, repito, para poner ejemplos de herencia. 00:00:00
Pues yo tengo aquí mi clase cliente, que era con la que he hecho yo mi aplicación, cualquiera, que tiene solamente estas propiedades, NIF por ejemplo, podría tener su constructor, getter, setter, modificador privado, todo eso, pero bueno, ahora vamos a ver de forma muy aislada lo de la herencia, para que quede claro cómo funciona. 00:00:27
Vale, entonces mi aplicación está hecha con esta clase cliente, su nombre, su NIF, sus cosas y ahora es cuando necesito incorporar una nueva entidad que son los clientes VIP. 00:01:02
vale, pues entonces 00:01:14
me hago yo una clase 00:01:16
ala, me hago esta clase 00:01:19
y esta clase en el momento de hacerlas 00:01:29
cuando digo, a ver 00:01:31
cuidado que cliente VIP 00:01:33
es un cliente 00:01:35
luego al ser cliente VIP 00:01:37
un cliente va a tener nombre y NIF 00:01:39
y todo lo que tiene cliente, porque lo es 00:01:41
entonces en lugar de 00:01:44
poner aquí otra vez, nombre, NIF 00:01:46
los métodos que sean, todo 00:01:48
en lugar de hacer eso 00:01:49
digo, vale, como es un cliente 00:01:51
porque sé que lo es a todos los efectos 00:01:54
porque ya he analizado 00:01:56
mi aplicación, he visto todos los casos 00:01:57
todas las situaciones, la tengo muy analizada 00:02:00
y he visto que lo es 00:02:01
pues entonces 00:02:02
hago mi Stents 00:02:04
¿Dijiste que no? 00:02:06
¿Que llevan en mayúscula? 00:02:13
Que es una 00:02:15
es muy habitual, porque normalmente 00:02:16
son datos constantes 00:02:18
para que usen todas las, entonces es 00:02:21
relativamente habitual que los encontréis 00:02:22
escritos con mayúsculas 00:02:24
¿Todo mayúscula o qué pi? 00:02:25
Todo, todo mayúscula. 00:02:26
Vale. 00:02:30
Vale. 00:02:31
Depende de lo que representen, claro. 00:02:32
Bueno, pues cuando representan constantes, 00:02:35
que es la mayoría de los casos, 00:02:37
pues como pi, el número e, 00:02:38
todos esos que vimos en la clase más del último día, 00:02:42
pues ya vemos que van con mayúsculas. 00:02:45
Vale, a ver, entonces, 00:02:48
yo tengo esta nueva entidad, cliente VIP, 00:02:49
al darme cuenta de que un cliente VIP 00:02:52
a todos los efectos de mi aplicación, 00:02:53
para todos los efectos 00:02:56
y todo esto viene porque he hecho un buen análisis 00:02:57
yo no tendría que estar aquí sentada 00:03:00
escribiendo si antes 00:03:02
no he hecho un buen análisis en el que he entendido 00:03:04
exactamente qué es cada entidad 00:03:06
por qué se caracteriza 00:03:08
qué va a hacer 00:03:10
en mi aplicación, hasta que no tenga 00:03:12
todo eso entendidísimo, no tiene sentido que uno se siente 00:03:14
que hay que hacer nada, bueno, como ahora lo tengo 00:03:16
entendidísimo, ya he visto que a todos los efectos 00:03:18
un cliente VIP 00:03:20
es un cliente también, no hay nada que le distinga 00:03:22
de un cliente, a todos los objetos es un cliente 00:03:24
pero además 00:03:26
añade algo particular 00:03:28
¿qué añade? 00:03:29
pues bueno, añade en este caso 00:03:32
nos dicho por ejemplo la dirección 00:03:34
añade esto 00:03:36
vale, pues ahora ya tengo 00:03:40
dos clases 00:03:44
dos clases de las que yo instancio 00:03:45
objetos completamente 00:03:48
distintos 00:03:50
uno es de la clase cliente y otro es de la clase 00:03:51
cliente VIP, instancio todos los objetos 00:03:54
que quiera de cada clase 00:03:56
bueno, pues vamos a hacer 00:03:57
un main ahora 00:04:00
vale, pues yo tengo aquí mi main 00:04:01
por supuesto puedo crear objetos cliente 00:04:14
normales y corrientes, como siempre 00:04:17
cliente c1 00:04:19
new cliente 00:04:21
vale 00:04:26
se ha creado 00:04:27
con su constructor por defecto 00:04:29
porque no he hecho ningún constructor 00:04:31
aquí, entonces recordad 00:04:33
que si uno no especifica 00:04:35
un constructor es ahí 00:04:37
se supone que hay uno por defecto 00:04:38
sin parámetros que no hace nada 00:04:41
vale 00:04:42
vale, pues igual que puedo hacer 00:04:44
un cliente o dos o tres o mil 00:04:46
pues puedo hacer también 00:04:49
objetos cliente VIP 00:04:50
también tranquilamente 00:04:52
ah, que no he puesto nombre en la variable 00:04:53
vale, y aquí está 00:05:09
mi cliente VIP 00:05:18
hasta ahí, todo como siempre 00:05:19
y C1 es 00:05:22
completamente independiente de C2 00:05:24
C1 tiene sus dos propiedades 00:05:26
Nombre y NIF 00:05:29
C2 tiene sus 00:05:32
Tres propiedades 00:05:34
Nombre, NIF y 00:05:35
Y dirección 00:05:38
¿Vale? 00:05:40
Entonces yo aquí podría, estoy pasando de los 00:05:42
Getter y los Setter y todo un poco por comodidad 00:05:44
Pero sería igual, pues yo aquí podría 00:05:46
Ponerle a mi cliente 1 su NIF 00:05:48
Podría ponerle 00:05:51
A mi cliente 1 su nombre 00:05:55
No es que aún no es VIP 00:05:57
Es que no es VIP 00:06:06
No está destinado a ser VIP 00:06:08
Es un cliente C1 00:06:09
Y solo tiene estas dos propiedades 00:06:11
Y ya está y no tiene más 00:06:13
Las que tiene aquí 00:06:14
Vale 00:06:16
Pues este de aquí 00:06:16
Este de aquí, C2 00:06:26
Como vemos 00:06:28
Este sí que tiene tres propiedades distintas 00:06:30
pues yo le puedo poner su if 00:06:33
el que me dé la gana 00:06:35
y estos son dos objetos 00:06:36
independientes, este tiene 00:06:58
sus propiedades y este tiene 00:07:00
sus otras, o sea la herencia 00:07:03
no establece entre ellos una relación 00:07:05
en tiempo de ejecución 00:07:07
o sea la herencia no es una relación entre objetos 00:07:08
este es 00:07:11
un objeto y este es otro y van por libre 00:07:13
la herencia 00:07:15
en realidad es una relación en tiempo 00:07:16
de escritura de código 00:07:19
stents, lo que me permite 00:07:20
es ahorrarme el copia y pega 00:07:23
pero son dos objetos independientes 00:07:25
¿vale? no tienen nada que ver el uno con el otro 00:07:26
bueno pues hasta ahí 00:07:29
tampoco hemos ganado 00:07:33
nada respecto a olvidarnos de la herencia 00:07:35
¿no? porque yo 00:07:37
podría haber hecho aquí en cliente VIP 00:07:39
haber hecho mi copia y pega 00:07:41
si yo hago mi copia y pega 00:07:43
lo pongo aquí y quito 00:07:45
el stents, estoy en la misma 00:07:47
situación ¿verdad? 00:07:49
¿no? 00:07:52
podría decir, mira voy a pasar de la 00:07:52
claro que hasta aquí 00:07:54
tampoco es que hayamos aportado nada especialmente 00:07:55
estupendo, porque podría decir 00:07:58
bueno hombre, solo el copia y pega 00:08:00
pues para eso 00:08:01
te haces esto 00:08:04
te haces esto, quitas el stents 00:08:05
y estás haciendo 00:08:09
exactamente lo mismo, pues sí 00:08:12
efectivamente, estamos haciendo 00:08:14
exactamente lo mismo 00:08:16
lo mismo, vale 00:08:17
pero 00:08:20
como hemos identificado que un cliente 00:08:22
viper era de cliente, pues hemos dicho, bueno, 00:08:24
pues voy a marcarlo 00:08:26
y además 00:08:27
ya no copio esto aquí. 00:08:29
Pero es una cuestión de copia y pega hasta ahora. 00:08:32
Nada más. 00:08:34
Luego estos objetos son absolutamente independientes. 00:08:36
C2 no tiene ninguna 00:08:39
relación con C1. Absolutamente ninguna. 00:08:40
C1 tiene su NIF y su nombre 00:08:42
y C2 tiene su NIF, su nombre 00:08:44
y su dirección. No tiene ninguna 00:08:46
relación uno con el otro. 00:08:48
¿Qué es lo que sí que ganamos? 00:08:52
Pues 00:08:55
esto de aquí 00:08:55
yo tengo un objeto 00:08:57
ahora mismo 00:08:59
que voy a instanciar en algún momento 00:09:02
en algún momento lo crearé 00:09:06
es un espacio ahí para un cliente 00:09:08
que aparecerá 00:09:10
pero todavía no sé qué tipo de cliente va a ser 00:09:11
no tengo ni idea 00:09:14
bueno 00:09:14
pues lo declaro como cliente 00:09:16
porque no sé si va a ser cliente normal 00:09:19
o cliente B, pero un cliente va a ser 00:09:22
porque recordemos que cliente VIP 00:09:24
en realidad es un caso particular 00:09:26
luego un cliente, no sé qué tipo de cliente va a ser 00:09:28
pero un cliente va a ser 00:09:30
pues yo lo declaro como cliente 00:09:31
y ahí 00:09:35
puede pasar lo que sea, cualquier cosa 00:09:35
ahora toca el momento de crear el cliente 00:09:38
pues al objeto 00:09:40
C3 puedo guardar 00:09:42
cualquier tipo de objeto 00:09:45
eso es lo importante 00:09:47
que puedo guardar 00:09:49
objetos de la 00:09:55
clase 00:09:56
cliente 00:09:58
o de cualquier subclase 00:09:59
de cualquier subclase 00:10:08
entonces ahora llega el momento en que ya 00:10:09
C3 va a cobrar valor 00:10:11
ahora ya C3 va a aparecer en mi programa 00:10:13
y va a cobrar valor 00:10:15
por supuesto puede recibir un cliente normal 00:10:16
pero es que C3 también puede recibir 00:10:19
un cliente VIP 00:10:21
si a mi me da la gana 00:10:23
y no hay ningún problema 00:10:24
aunque esté declarado como cliente 00:10:26
puede recibir un objeto 00:10:29
de la propia clase cliente 00:10:31
o de cualquiera de las subclases 00:10:33
me da igual 00:10:35
porque el cliente VIP es un objeto 00:10:36
también 00:10:39
entonces 00:10:40
esto sobre todo 00:10:49
lo vemos más utilidad 00:10:52
cuando tenemos que hacer muchos objetos 00:10:54
que es lo habitual 00:10:57
yo tengo un array de clientes 00:10:58
un montón de array de clientes 00:11:00
voy a trabajar con 100 por ejemplo 00:11:01
con 100 00:11:06
y ahora 00:11:09
Cada cliente del array 00:11:11
Puede ser del tipo que le dé la gana 00:11:13
Por ejemplo 00:11:15
Por ejemplo 00:11:17
Clientes 0 00:11:18
Pues aquí quiero meter o me toca meter 00:11:20
O me han dicho que meta o lo que sea 00:11:23
Un cliente normal 00:11:25
Vale, pues ahí va un cliente normal 00:11:26
Pero en clientes 1 00:11:28
Toca meter o 00:11:31
Me han dicho o lo que sea 00:11:32
Toca meter un cliente VIP 00:11:34
Bueno, pues ahí puede ir 00:11:36
Un cliente VIP 00:11:39
Y ningún problema. 00:11:39
Entonces, esta es la utilidad fundamental. 00:11:56
Luego ya, claro, tiene detalles para que todo esto encaje dentro de la aplicación completa. 00:11:59
Pero la idea es esta. 00:12:06
Dentro de una referencia de la superclase, puedo meter objetos de cualquiera de las subclases. 00:12:07
Esta es la idea. 00:12:15
Vale, lo único es que, claro, ahora tenemos un pequeño problemilla. 00:12:18
si yo lo he trabajado así 00:12:23
si he declarado la referencia 00:12:25
como cliente, porque 00:12:28
todavía no sé, todavía no sé 00:12:29
qué tipo de cliente va a ir, no sé si va a ir 00:12:31
VIP, si va a ir no sé qué, no sé qué tipo de cliente 00:12:33
va a ir, le he declarado como C3 00:12:35
ahora yo 00:12:38
quiero por ejemplo rellenar el nombre 00:12:39
ningún problema, nombre, vale 00:12:46
pues este nuevo cliente, venga 00:12:49
ya está 00:12:51
ahora, quiero 00:12:52
rellenar el NIF 00:12:55
muy bien, ningún problema 00:12:57
aquí está el NIF 00:12:58
pero ahora de este objeto C3 que acabo de crear 00:13:00
de este objeto 00:13:03
como lo he creado como cliente VIP 00:13:05
tiene espacio para sus tres campos 00:13:07
pues ahora quiero yo 00:13:08
rellenar la dirección 00:13:10
y quiero poner ahí lo que sea 00:13:12
pues el compilador aquí 00:13:18
se queja 00:13:23
y te protesta 00:13:25
y no te deja 00:13:27
porque el compilador 00:13:29
trabaja con reglas muy estrictas 00:13:30
y dice, vamos a ver, C3 00:13:32
C3 voy a buscar 00:13:34
cómo está declarado 00:13:36
el compilador mira cómo está declarado 00:13:38
no cómo está instanciado, eso no le importa 00:13:40
porque puede estar instanciado de cualquier manera 00:13:42
eso le da igual, puede estar instanciado como 00:13:44
BIP, como, él mira cómo 00:13:46
está declarado, dice, a ver C3 00:13:48
tú cómo estás declarado 00:13:50
estás declarado como cliente 00:13:52
vamos a ver qué tiene cliente 00:13:54
qué tiene nombre y NIF, no tiene más 00:13:56
con lo cual lo siento mucho 00:13:58
no te dejo 00:14:00
acceder a esta propiedad 00:14:03
porque C3 lo has declarado 00:14:05
como cliente 00:14:07
y aquí 00:14:08
no hay cliente, entonces no puedo 00:14:11
físicamente 00:14:13
el objeto claro que tiene ese espacio 00:14:17
lo tiene porque yo lo he instanciado como no cliente 00:14:19
físicamente está 00:14:21
pero a nivel de escritura de código 00:14:22
el compilador no me deja 00:14:25
porque él sigue sus reglas y sus reglas 00:14:27
son claras. Si C3 es de clase cliente, lo siento mucho, pero no te 00:14:29
dejo acceder a una propiedad que no está. Claro, es que 00:14:33
aquí entra a hacer el diseño correcto, pues con getter y setter. 00:14:37
Porque los métodos también se heredan. 00:14:41
Entonces, ¿cómo haríamos esto? No lo haríamos así. 00:14:45
¿Cómo haríamos esto si lo hiciéramos bien hecho? Cliente tendría 00:14:49
sus get y sus set. Estas serían propiedades privadas 00:14:53
y cliente 00:14:56
tendría sus get y set 00:14:59
vale, aquí tendría sus get y sus set 00:15:00
entonces ahora cliente vip 00:15:12
vale 00:15:13
esas propiedades las tiene 00:15:15
aunque aquí no aparezcan, las tiene 00:15:18
y además yo le añado 00:15:20
esta, vale 00:15:23
entonces no solo tiene estas 00:15:25
propiedades, aunque yo no las vea físicamente 00:15:27
no solo las tiene 00:15:30
aquí 00:15:31
sino que además 00:15:33
tiene los get y los set 00:15:35
porque todos los métodos 00:15:37
se heredan, salvo los constructores 00:15:39
también los tiene 00:15:41
entonces ya aquí en cliente VIP 00:15:42
con hacer el get y el set de dirección 00:15:44
que es el único que tengo que añadir, suficiente 00:15:47
ah, la tengo yo, mi get y set 00:15:49
de dirección 00:15:56
y ahora ya a través de esos get y set 00:15:57
heredados 00:16:02
ya accedo a las propiedades, que es lo que debería hacer 00:16:02
a través de los get y set heredados 00:16:06
entonces ahora 00:16:07
¿qué problema tengo yo aquí? 00:16:09
Y lógicamente, que no puedo acceder a la propiedad directamente, pues que quiero setNif, ala, ya está, del cliente C1. 00:16:11
Ahora quiero ponerle un nombre a este cliente, setNombre, pues el que fuera, vale. 00:16:22
Ahora, este cliente VIP 00:16:35
Este cliente VIP 00:16:37
Puede tranquilamente 00:16:39
Poner aquí su NIF 00:16:42
Estoy rehaciéndolo de arriba 00:16:44
Set NIF igual a esto 00:16:46
Este cliente C2 00:16:48
Puede, por supuesto 00:16:58
Poner su nombre 00:16:59
Y puede poner 00:17:02
Su dirección a través del 00:17:07
Set suyo 00:17:09
Vale 00:17:10
Y ahora, este que era el caso problemático 00:17:23
este que era el caso problemático 00:17:26
cliente declarado como 00:17:29
clase cliente 00:17:31
C3, declarado como clase cliente 00:17:33
pero instanciado como subclase 00:17:36
cliente VIP, entonces al estar 00:17:39
instanciado como subclase 00:17:41
cliente VIP, al estar instanciado así 00:17:43
él tiene sus 00:17:45
tres propiedades ahí en memoria, eso sí 00:17:47
que no falla, tiene sus tres 00:17:49
ahora las tres accesibles 00:17:50
pero accesibles a través de 00:17:53
esto de aquí 00:17:55
setNif 00:17:58
era nombre lo que tenía aquí 00:17:59
setNombre 00:18:06
vale 00:18:07
cliente 00:18:08
setNif, vale 00:18:14
y ahora 00:18:26
a ver, perdonad que se me ha ido la pinza y os he dicho una cosa mal 00:18:27
vale 00:18:36
que no la tiene accesible tal cual 00:18:36
vale, entonces ahora nos viene 00:18:39
el problema este 00:18:41
c3.setDirección 00:18:42
Set dirección. 00:18:45
No sale. 00:18:48
Si yo la forzara y la pusiera, 00:18:50
set dirección, 00:18:52
oslo. 00:18:54
Si yo la forzara y la pusiera, 00:18:57
el compilador vuelve a hacer lo mismo otra vez. 00:18:59
Me vuelve a decir, espérate, 00:19:01
C3 está declarado como cliente, 00:19:03
vamos a ver si tienes un método set dirección aquí. 00:19:06
Si lo tienes. 00:19:11
Pues no. 00:19:14
No lo tienes, entonces no te lo puedo permitir. 00:19:15
Entonces, ¿qué es lo que tenemos que hacer? 00:19:21
Pues como hemos visto que la instanciación es de cliente VIP 00:19:24
y aquí ya estamos después de la instanciación, 00:19:28
lo que aquí tenemos que hacer es un casting. 00:19:32
Entonces, recordad lo que era un casting. 00:19:54
Un casting era delante de una variable 00:19:57
poner un tipo de dato 00:20:01
al que le 00:20:03
al que le convierto 00:20:04
vale 00:20:06
entonces 00:20:08
yo aquí delante de C3 00:20:10
pongo cliente VIP 00:20:12
eso significa 00:20:15
que le estoy diciendo al compilador 00:20:17
le estoy diciendo 00:20:20
oye 00:20:21
trata C3 00:20:21
como si fuera cliente VIP 00:20:23
es lo que le estoy diciendo 00:20:24
trata C3 00:20:26
como si fuera cliente VIP 00:20:27
vale 00:20:28
pues él lo trata 00:20:29
como si fuera cliente VIP. ¿Hay algún problema 00:20:31
en que lo trate como si fuera cliente VIP? 00:20:33
No hay ningún problema porque lo es. 00:20:35
Entonces, este casting 00:20:37
tiene que ser un casting controlado. 00:20:38
Solo tiene sentido si C3 está 00:20:41
instalado, instanciado previamente 00:20:42
como cliente VIP. Si no está instanciado 00:20:45
como cliente VIP, esto 00:20:47
sería un desastre. 00:20:49
¿Vale? Entonces, están diciendo, oye, 00:20:51
trátalo como cliente VIP. 00:20:53
Entonces, al tratarlo como cliente VIP, 00:20:54
ya me habilita todo 00:20:57
lo que tenga cliente VIP. 00:20:58
Pero este casting, este decirle trátalo como si fuera cliente BIT, tiene que estar conectado a que realmente esté creado como cliente BIT, porque si no, sería un desastre. El compilador lo tragaría, pero sería un desastre. 00:21:01
Es decir, cuidado, imaginaos que… Bueno, sí, dime. 00:21:19
claro, es que lo de los constructores 00:21:29
lo vamos a ver ahora, porque los constructores al no heredarse 00:21:40
hay que hacerlos de forma específica, ahora nos metemos 00:21:42
vale, ahora nos metemos 00:21:44
vale, entonces esta es la primera idea 00:21:46
vale, entonces 00:21:48
la clase heredera tiene 00:21:49
copias y pegas de todo lo de arriba 00:21:53
excepto constructores 00:21:55
que ahora nos metemos con constructores 00:21:57
excepto constructores 00:21:59
¿Qué implicaciones tiene? 00:22:00
Que yo puedo instanciar 00:22:04
Puedo instanciar 00:22:05
Objetos de cualquier subclase 00:22:07
Y meterlos en referencias de la superclase 00:22:10
Pero 00:22:12
Esto me trae un problema 00:22:14
A la hora de escribir el código 00:22:17
Por un tema de protección 00:22:19
De que no hagas burradas 00:22:21
¿Qué es? 00:22:22
Vale, muy bien 00:22:24
Por ganar flexibilidad 00:22:25
Por ganar flexibilidad 00:22:27
hay veces que es imprescindible 00:22:28
lo has declarado como cliente C3 00:22:30
muy bien 00:22:33
y luego lo has instanciado como cliente VIP 00:22:34
bien, ningún problema 00:22:36
pero entonces el compilador 00:22:38
cuando tú trates de acceder 00:22:41
a algo que está en cliente VIP 00:22:43
no te lo va a permitir 00:22:44
porque solo te va a permitir acceder 00:22:47
a lo que esté aquí arriba 00:22:48
tal y como se ha declarado 00:22:50
entonces si queremos acceder 00:22:53
a lo que tiene 00:22:55
él como objeto instanciado 00:22:57
a lo que tiene como objeto instanciado 00:22:59
hay que decirle mediante un casting 00:23:00
trátale como si fuera 00:23:02
así, aunque esté declarado 00:23:04
de la otra manera 00:23:07
¿vale? con este casting le decimos 00:23:08
al compilador que lo considere 00:23:25
como 00:23:27
objeto 00:23:29
de clase 00:23:31
clase VIP 00:23:33
¿vale? es lo que le decimos con ese casting 00:23:37
oye, consideralo pero para 00:23:45
esta línea, solo de código, claro, para esta línea. 00:23:47
Considéralo como objeto de clase 00:23:50
VIP, de clase, perdón, cliente 00:23:51
VIP. ¿Vale? Solo para esta línea 00:23:53
de código. Considéralo como clase 00:23:58
cliente VIP. Entonces, ahora ya 00:24:00
podemos acceder a todo lo que hay adentro. 00:24:02
¿Vale? 00:24:11
Entonces, claro, vosotros podéis decir, 00:24:13
hombre, pero entonces 00:24:15
si hay que decirle 00:24:17
al compilador, porque el compilador 00:24:19
se te queja y se te pone pesado, 00:24:20
cuando quieres acceder a algo propio 00:24:23
del objeto, algo propio y no heredado 00:24:24
algo propio, hay que decirle 00:24:27
que lo trate 00:24:29
como objeto de esa clase 00:24:30
pues para eso 00:24:32
declarémoslo directamente como objeto de esa clase 00:24:34
y nos ahorramos problemas 00:24:37
si aquí lo hubiéramos 00:24:38
declarado directamente como objeto 00:24:41
cliente VIP 00:24:43
me habría ahorrado tener que hacer 00:24:44
todo esto, ¿verdad? 00:24:46
es lo que hemos hecho arriba, si yo lo 00:24:50
declaro como cliente VIP 00:24:52
directamente no tengo que 00:24:53
decirle al compilador, oye, trátalo como cliente VIP. 00:24:56
Entonces, ¿por qué no lo hacemos 00:24:59
siempre así? En lugar de declararlo 00:25:00
como la superclase, 00:25:02
luego ya instanciarlo como la 00:25:04
subclase y entonces complicarnos 00:25:06
la vida, porque no nos va a 00:25:08
quedar más remedio que 00:25:10
hacerle el casting. 00:25:12
Para decirle, trátalo. 00:25:14
Porque, primero, 00:25:16
porque hay veces que no queda más remedio. 00:25:18
Por ejemplo, ahora. 00:25:20
Y segundo, en situaciones 00:25:22
como esta, esta es la clave 00:25:24
cuando tú quieres guardar 00:25:26
un montón de objetos de diferentes 00:25:28
tipos en una misma colección 00:25:30
de datos, en este caso un array 00:25:32
que es la misma colección de datos que conocemos 00:25:34
cuando queremos guardar muchos 00:25:36
en un mismo array 00:25:38
es que aquí no hay tu tía, tienen que ir 00:25:39
declarados todos como cliente, aquí no puedo elegir 00:25:42
aquí no puedo elegir 00:25:45
entonces 00:25:46
aquí 00:25:48
sí que tendría el problema 00:25:49
que cliente es uno 00:25:53
si clientes 1 le quiero fijar su dirección 00:25:54
aquí por ejemplo 00:25:57
a clientes 1 00:25:59
le quiero fijar su dirección 00:26:01
con set dirección 00:26:03
pues no puedo 00:26:04
tendría que hacer el casting 00:26:06
vale 00:26:13
pero claro 00:26:16
tiene que ser un casting controlado 00:26:18
ahora veremos un poco más 00:26:20
también como controlarlo para no cargar 00:26:22
no cargarnos el programa en ejecución 00:26:23
porque yo puedo hacer casting 00:26:26
a lo que me dé la gana, pero si no encaja 00:26:27
¿qué miráis con ese interés? 00:26:30
Ah, no sabía que limpiaban eso. 00:26:33
Bueno, ¿es más interesante 00:26:39
eso que esto? 00:26:40
No creo. 00:26:42
Vale. 00:26:44
Bueno, está 00:26:48
claro que en esta situación 00:26:49
que en esta situación 00:26:51
es que no tenemos alternativa. 00:26:53
Vamos a tener que hacer el casting 00:26:56
porque todos los objetos que van aquí 00:26:58
están declarados de este tipo. 00:26:59
Entonces, no me queda más remedio. 00:27:01
Pero hay otras situaciones en las cuales 00:27:03
el declarar como la superclase es básico también. 00:27:05
Por ejemplo, vamos a hacer un método 00:27:09
para mostrar el nombre del cliente. 00:27:11
Un método cualquiera que está por aquí 00:27:16
para mostrar datos cliente. 00:27:18
Vale. 00:27:32
Entonces, mostrar datos cliente, 00:27:33
El cliente hay que pasárselo como parámetro 00:27:35
Bueno, pues aquí de nuevo nos viene la duda 00:27:38
A ver, este método 00:27:41
Quiero yo que me valga solo para clientes VIP 00:27:43
Porque entonces a este método 00:27:47
Le paso cliente VIP 00:27:49
Vale 00:27:52
Quiero que me valga para cualquier tipo de cliente 00:27:54
Que este método lo pueda llamar 00:27:59
Para mostrar datos de un cliente VIP 00:28:01
Mostrar datos de un cliente 00:28:02
sí, quiero poder llamar a este método 00:28:04
para cualquier tipo de cliente. 00:28:06
Pues entonces no te queda más remedio que llamarlo así. 00:28:08
Entonces, este 00:28:11
método le puedes pasar 00:28:12
un objeto cliente normal, 00:28:13
un objeto cliente VIP, 00:28:17
porque también encaja ahí, 00:28:18
un objeto cliente moroso, 00:28:20
si tienes tú una subclase, 00:28:22
cliente moroso de cliente, lo que te dé la gana. 00:28:24
Entonces, esta es otra 00:28:27
situación 00:28:28
en la que es que no puedo elegir. 00:28:28
Si yo quiero que este método 00:28:32
sea usable, utilizable 00:28:33
para cualquier tipo de cliente 00:28:35
para cualquiera, tengo que poner 00:28:38
aquí la referencia de la superclase 00:28:40
porque si no tendría 00:28:42
que hacer un método específico para mostrar datos 00:28:44
cliente VIP, y aquí poner cliente VIP 00:28:46
mostrar datos específicos 00:28:47
cliente moroso, y ahí poner cliente moroso 00:28:50
entonces no tiene sentido un método 00:28:52
mostrar datos 00:28:54
para cada tipo de cliente 00:28:55
a mí me interesa más en mi aplicación 00:28:57
un dato, mostrar dos clientes, le paso 00:28:59
a un cliente y él ya 00:29:02
que muestre, me da igual que sea BIP, que sea 00:29:04
genérico, que sea lo que sea. 00:29:06
Luego 00:29:10
me voy a ver 00:29:11
en muchas situaciones en las de 00:29:13
situra de haber declarado 00:29:15
una variable de una 00:29:18
superclase y luego 00:29:19
haberla instanciado como la subclase. 00:29:21
Pues si eso ha ocurrido 00:29:24
para acceder 00:29:26
al contenido de la subclase 00:29:27
tengo que hacer 00:29:29
este casting. 00:29:31
Tengo que hacer este casting 00:29:33
¿Te has muerto? 00:29:35
Vale 00:29:42
Ya vamos a 00:29:42
Ya vamos a callarnos en breve 00:29:45
Que no tenía nada que ver con programación 00:29:47
Vale, entonces 00:29:51
Ahora vosotros que estáis ahí 00:29:53
Al quite de cualquier cosa 00:29:55
Me diréis 00:29:57
Ay, perdona 00:29:58
Esta vez no va a pasar 00:30:00
que ya estabais ahí con la incógnita 00:30:05
diréis vosotros 00:30:08
vale, estupendo, con esto 00:30:10
de que la subclase 00:30:12
cabe en la superclase, que bien 00:30:14
un único método 00:30:16
para mostrar datos de cualquier cliente 00:30:17
estupendo, vale, pero ahora vienen los problemas 00:30:20
cuando nos pongamos aquí dentro 00:30:22
ahora vienen los problemas 00:30:23
porque decimos, espérate, yo hago este método 00:30:25
y es que no tengo ni idea 00:30:28
de V que mostrar 00:30:30
es decir, la dirección 00:30:32
la puedo mostrar seguro. 00:30:34
¿Verdad? 00:30:37
Es decir, v voy a poder 00:30:38
mostrar su nif, perdón. 00:30:40
Mucha dirección. 00:30:43
Vale, hasta aquí sin problema. 00:30:44
nombre también 00:30:48
estupendamente. 00:30:50
Pero ahora me viene aquí un problema gordo 00:30:53
que es, tú me has pasado un objeto 00:30:54
cliente v 00:30:56
y yo no sé 00:30:58
si es un cliente normal 00:31:00
o si es un cliente v. 00:31:02
Porque en el caso de que sea un cliente VIP, la hemos liado, voy a necesitar mostrar aquí el otro dato que me falta. Si quiero que este método sea completo y funcione para todos, si quiero que sea completo y funcione para todos, tengo que averiguar de alguna manera si este que me has pasado se ha creado, se ha instanciado como VIP para además añadir lo que falta. 00:31:04
pues así me he quedado 00:31:26
¿tengo alguna herramienta 00:31:28
para ver cómo se ha instanciado 00:31:31
un objeto 00:31:33
de una superclase? 00:31:35
sí que la tengo, que es el 00:31:37
instance of 00:31:38
entonces yo ahora, aquí he mostrado 00:31:39
esto me vale, me da igual que v 00:31:42
bueno, esto de v es que es muy feo 00:31:44
me da igual que c 00:31:47
sea genérico o v 00:31:53
porque estas dos propiedades las tiene 00:31:54
estas las voy a mostrar sí o sí 00:31:56
pero ahora 00:31:57
yo hago lo siguiente 00:31:59
si c 00:32:02
instance of 00:32:03
cliente 00:32:06
vip 00:32:09
¿y qué es el instance of? 00:32:10
pues es un operador maravilloso 00:32:14
que te dice 00:32:17
si este objeto 00:32:18
se instanció como esta clase 00:32:20
si se instanció 00:32:23
como la clase que pongas aquí 00:32:25
eso te devuelve true 00:32:27
si no te devuelve false 00:32:28
entonces si el objeto que me han pasado aquí 00:32:30
se instanció como cliente 00:32:33
VIP, maravilloso 00:32:35
ya sé que le puedo hacer ese casting 00:32:37
y ya muestro lo que me falta 00:32:39
entonces ahora ya podríamos hacer 00:32:40
tranquilamente 00:32:43
cliente VIP de C 00:32:44
punto get dirección 00:32:52
y ahora todo esto 00:32:55
al system 00:32:57
Me falta uno aquí 00:32:58
Ese, me falta 00:33:41
Pues este ahora ya es un método 00:33:42
Como es la idea 00:33:51
Que me vale para cualquier tipo de cliente 00:33:52
Que esa es la idea 00:33:54
Poder hacer una relación entre clases 00:33:55
De forma que pueda yo tratar conjuntamente 00:33:57
A todos los clientes 00:34:00
Sean bien morosos 00:34:02
a todos los animales 00:34:03
sean gatos, perros, ratones 00:34:04
así tengo que hacer los diseños 00:34:06
entonces yo tengo un método, vamos a ver esto del cliente 00:34:08
y le paso a un cliente 00:34:11
que puede ser de cualquier 00:34:12
tipo, de este 00:34:15
o de las subclases, de cualquiera 00:34:16
pero claro 00:34:18
voy a tener que tirar de este operador 00:34:20
no me va a quedar más remedio 00:34:22
para ahora ya, una vez 00:34:24
metida en las tripas del método 00:34:26
pues distinguir en función 00:34:28
del tipo que sea, hacer ya una cosa u otra 00:34:30
porque serán objetos distintos, lógicamente 00:34:32
bueno, pues la combinación de estas ideas 00:34:35
es lo fundamental, luego a partir de aquí 00:34:46
ya son detallitos 00:34:48
pues de constructores, de no sé qué, de ciertas 00:34:49
cosas, pero lo importante es tener 00:34:52
la idea clara 00:34:53
las ideas claras siguientes 00:34:55
que 00:34:57
la herencia con Stents 00:34:59
lo que te facilita 00:35:02
es, primero 00:35:04
la escritura del código porque te permite 00:35:05
crear otra clase distinta 00:35:07
otra clase distinta 00:35:09
copiando y pegando las propiedades de otra 00:35:11
otra clase distinta 00:35:14
pero claro, solamente la uso 00:35:15
si realmente puedo enunciar 00:35:18
cliente VIP 00:35:20
es cliente 00:35:21
si puedo sustituir extents por es 00:35:23
entonces pues sí, tiene sentido 00:35:25
si no puedo sustituir 00:35:27
si esto no lo puedo 00:35:29
sustituir 00:35:32
por es 00:35:33
y no me pega 00:35:35
y me queda ahí una frase absurda 00:35:36
pues ese diseño te lo tiras a la basura 00:35:39
porque ese diseño está muy mal hecho 00:35:41
¿vale? eso por un lado 00:35:42
bueno, pues entonces 00:35:45
una vez que yo he establecido relaciones de herencia 00:35:46
ya correctamente 00:35:49
ahora yo puedo tratar a todos los objetos 00:35:50
de las subclases 00:35:53
a todos de forma común 00:35:54
¿vale? como aquí 00:35:56
todos mis clientes 00:35:58
todos mis clientes 00:36:01
están metidos en referencias 00:36:03
de tipo cliente 00:36:05
y están tratados de forma común 00:36:06
y ahora ya, que yo quiero mostrar datos 00:36:08
de un cliente 00:36:11
vale, pues por ejemplo 00:36:12
mi método mostrar datos cliente 00:36:20
que está aquí, pues le puedo pasar 00:36:22
cualquier cliente 00:36:27
le puedo pasar mi cliente 00:36:28
C1, que era cliente normal 00:36:31
vale 00:36:32
se lo puedo pasar 00:36:34
y mostrar los datos del C1 00:36:36
Pero es que también a ese método 00:36:39
También le puedo pasar el C2 00:36:41
Que era de otro tipo 00:36:45
Y me mostrará en ese caso 00:36:46
Los datos del otro 00:36:49
Y le puedo pasar cualquier objeto 00:36:50
Que sea de la clase cliente o de las subclases 00:36:52
¿Vale? 00:36:55
Aquí en este caso 00:36:56
Voy a ver las C1 y C2 00:36:57
Que C1 tenía esto y C2 tenía esto 00:37:00
Pues voy a ver 00:37:03
Las cinco líneas cuando ejecute esto 00:37:04
El primer mostrar datos me ha hecho esto, los datos del primer cliente que era cliente normal y el segundo mostrar datos, este de aquí, me ha hecho esto, me ha mostrado el segundo, o sea, son dos objetos distintos de clases distintas, pero las he podido tratar con el mismo método. 00:37:06
Y esto sin la herencia tendría que haber hecho mostrar datos cliente general, mostrar datos cliente VIP. Sin la herencia tendría que duplicar un método por cada subclase, una colección por cada subclase, ¿vale? 00:37:33
Vale, venga, pues ahora ya sí que paramos aquí. 00:37:53
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:
12 de enero de 2026 - 21:12
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 56″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
147.18 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid