Saltar navegación

20260114 Herencia_4 - 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

A ver, que estábamos aquí, estábamos aquí. Una forma es poner el get, pero a ver, esto en realidad también es un poco feo, porque a lo mejor en mi entidad cliente, pues yo no quiero hacer los dos públicos, porque solamente quiero dar permiso de lectura para las clases que están fuera, etc. 00:00:00
entonces la heredera 00:00:20
es que es una clase especial, la quiero distinguir 00:00:22
de las demás, entonces que la 00:00:24
heredera entre por el mismo camino 00:00:26
que entran los extraños 00:00:28
pues hombre es feo 00:00:30
más que nada porque a lo mejor yo ni siquiera 00:00:32
he habilitado los dos caminos 00:00:34
a lo mejor he habilitado solamente el get 00:00:36
y el set no 00:00:38
o he habilitado 00:00:39
solamente el get de nombre pero el de nid 00:00:42
no, entonces 00:00:44
¿cuál es la alternativa habitual? 00:00:46
Pues poner el cuarto 00:00:48
Modificador de datos 00:00:51
Que mencionamos que existía 00:00:53
Pero que dijimos, tiene que ver con la lección y lo dejamos 00:00:55
¿Qué era? 00:00:58
Nadie habrá tenido 00:00:59
Una visión en la cabeza 00:01:00
Que de repente 00:01:03
Se ha acordado 00:01:05
De hace dos meses que lo mencionamos, ¿verdad? 00:01:06
No, a ver, que era una tontería 00:01:12
¿Quién se va a acordar de eso? 00:01:13
¿Os acordáis que mencioné esto? 00:01:15
Y dije, nos falta este modificador de acceso 00:01:17
pero todavía no podemos entender 00:01:20
qué significa, perdón, no es aquí donde quiero 00:01:22
ponerlo, perdón, no era aquí 00:01:24
lo quiero poner 00:01:26
en aquí, es decir 00:01:28
problema que estoy tratando de resolver 00:01:30
esta es la clase 00:01:32
cliente, que está diseñada 00:01:34
como Dios manda 00:01:36
propiedades privadas, get y set 00:01:38
¿vale? 00:01:40
entonces, ¿qué significa? 00:01:42
que ninguna clase 00:01:44
que no sea cliente puede hacer referencia 00:01:46
a nombre y nif 00:01:49
pero se nos queda una situación absurda 00:01:49
que es la que acabamos de ver 00:01:52
que cliente VIP es una clase 00:01:53
diferente a cliente 00:01:56
pero ella claro que tiene nombre y NIP dentro 00:01:57
los tiene dentro porque los ha heredado 00:02:00
los tiene, pero se da la situación 00:02:02
absurda de que no puede hacer 00:02:04
referencia a ellos, no puede porque hay un 00:02:06
private aquí y el compilador 00:02:08
es muy estricto 00:02:10
bueno pues para eso existe el modificador 00:02:11
protected 00:02:14
y ya es el último modificador de acceso 00:02:15
que es igual 00:02:19
a todos los efectos que private 00:02:21
igual, pero 00:02:23
deja como excepción 00:02:25
a las subclases 00:02:27
luego, con el modificador protected 00:02:28
nadie puede acceder a nombre 00:02:31
inif, salvo 00:02:33
las subclases 00:02:35
con lo cual 00:02:36
tiene todo el sentido, ahora yo ya desde cliente 00:02:39
vip, cuando yo quiera 00:02:41
acceder a mi nombre, que lo tengo 00:02:43
porque lo he heredado, yo tengo mi nombre 00:02:45
¿vale? pues ya podré 00:02:46
Y cuando yo quiera acceder a mi NIF 00:02:49
Que lo tengo, lo tengo dentro, lo he heredado 00:02:52
Es que forma parte de mi objeto 00:02:54
Pues ya podré 00:02:56
¿Vale? 00:02:58
Sí, dime 00:03:10
¿No has dicho tu profe, Diego? 00:03:11
Yo sí que tengo una voz en la cabeza 00:03:16
Lo ha dicho, pero no lo sabe 00:03:17
Bueno, pues esto sería lo más normal 00:03:22
ala pues volvemos 00:03:32
otra vez 00:03:37
entonces este método es un método 00:03:38
que está sobre escrito 00:03:41
es un método sobre escrito 00:03:43
y yo ya lo puedo dejar así 00:03:44
tranquilamente y ya está y ya sabemos 00:03:47
las implicaciones que tiene esto 00:03:48
que cuando desde cualquier sitio 00:03:50
por ejemplo desde este main 00:03:52
yo llame a este se llamará 00:03:54
la versión de cliente 00:03:56
pero sin embargo cuando lo llame 00:03:58
desde C2 se llamará 00:04:00
a la versión de este otro 00:04:02
ya lo sabemos, por eso es un método 00:04:04
polimórfico que tiene diferentes formas 00:04:06
para efectos de 00:04:08
clarificar el código 00:04:11
lo que se suele hacer es incluir 00:04:13
cuando uno sobrescribe un método 00:04:15
como aquí que lo hemos sobrescrito 00:04:18
estaría 00:04:20
estupendo 00:04:22
poner 00:04:22
algo que lo explicara 00:04:26
me diríais 00:04:28
pues un comentario, pues si los comentarios siempre 00:04:30
vienen bien, pero los comentarios son para los humanos 00:04:31
los comentarios luego cuando 00:04:34
las clases se compilan 00:04:36
los comentarios lógicamente desaparecidos son para los humanos 00:04:38
entonces existe otra cosa 00:04:40
que 00:04:42
este año prácticamente lo tendremos que utilizar 00:04:44
pero el año que viene continuamente 00:04:47
pero hay que configurarlo todo, existe otra cosa que se llaman 00:04:48
anotaciones 00:04:50
y las anotaciones no es que sea 00:04:51
no es código que se ejecuta 00:04:54
pero si es información 00:04:56
relacionada con el código 00:04:59
que el compilador tiene en cuenta 00:05:00
vale 00:05:03
y la máquina virtual también tiene en cuenta 00:05:04
para generar ciertas cosas 00:05:07
aunque ahora todavía no podamos 00:05:08
tener ningún ejemplo 00:05:11
y las anotaciones 00:05:12
empiezan por un arroba 00:05:14
y en este caso la anotación 00:05:16
que nos vendría maravillosa 00:05:19
uy la he puesto en cliente, perdón 00:05:22
aquí no, control x 00:05:24
aquí 00:05:26
entonces 00:05:28
yo he sobrescrito este método 00:05:29
lo he sobrescrito, este es un método sobrescrito 00:05:32
esto si es un comentario 00:05:35
super clase 00:05:42
vale, pues si además 00:05:47
soy tan hábil y me acuerdo 00:05:50
de avisar 00:05:52
de que este es un método sobrescrito 00:05:54
con esto que es 00:05:56
una anotación 00:05:58
que empieza con un arroba y hay 00:05:59
millones de miles de anotaciones 00:06:02
en particular la anotación que expresa 00:06:03
sobrescritura es overwrite 00:06:06
¿vale? 00:06:08
Pues si yo me acuerdo de poner la anotación 00:06:10
Diréis, pues ya está, no pasa nada 00:06:12
Hombre, pasa un montón 00:06:14
Es decir, el código funciona exactamente igual 00:06:16
Todo se ejecuta igual 00:06:19
No hay ningún cambio 00:06:20
Pero, ostras, el código es muchísimo mejor 00:06:21
Queda mucho más claro 00:06:25
Este es un método sobrescrito 00:06:26
Entonces yo ya sé 00:06:28
Que esto está ocultando la versión de la superclase 00:06:30
Ya sé eso 00:06:33
Entonces ya tiene cierto interés 00:06:35
¿Para qué me vale tan bien? 00:06:38
por ejemplo, imaginaos que yo mi intención era 00:06:40
sobre escribir el método, mostrar datos 00:06:44
porque no me gusta la versión de cliente 00:06:47
no me gusta nada esta versión 00:06:49
o más que no me gusta, no me vale 00:06:50
esta no me vale porque se queda corta 00:06:52
entonces yo la sobre escribo 00:06:55
y me equivoco 00:06:56
y pongo una S de más 00:06:58
por poner un ejemplo tonto 00:07:00
pues ahí me quedo tan tranquila 00:07:02
pensando que he sobre escrito el método 00:07:05
y ya está 00:07:07
mi método está sobre escrito 00:07:08
y yo luego cuando yo ofrezca esto 00:07:10
mi main, pues mi main llama 00:07:12
a mostrar datos 00:07:14
y no hay ningún error 00:07:15
claro, no hay ningún error, pero a qué mostrador estará llamando 00:07:17
ahora, al de la superclase 00:07:20
porque no lo ha sobrescrito 00:07:26
es decir, si yo me he equivocado 00:07:27
y me he creado este método con esta otra S 00:07:31
ahora en cliente 00:07:33
tengo dos que están 00:07:35
coexistiendo, el heredado 00:07:37
que yo no lo veo, que es este 00:07:39
el heredado que yo no lo estoy 00:07:41
viendo 00:07:43
pero que está aquí 00:07:43
y este nuevo 00:07:45
que es otro distinto 00:07:47
¿por qué? porque tiene otro nombre 00:07:49
luego es otro distinto, tiene dos 00:07:50
¿vale? no es sobrescrito nada 00:07:53
ha hecho otro distinto porque la firma es distinta 00:07:55
en este caso el nombre 00:07:58
entonces, ahora ya 00:07:59
mi clase tiene dos métodos 00:08:03
y cuando yo desde mi main 00:08:04
llame a mostrar datos, estaré llamando 00:08:06
al de la superclase 00:08:08
y si llamara a este otro, que no lo haría 00:08:10
porque se supone que ha sido por 00:08:12
error, ¿vale? 00:08:14
Estaría llamando 00:08:19
al de... 00:08:20
No, bueno, aquí no puedo porque en este ejemplo no puedo. 00:08:24
¿Vale? Y si llamo a este otro, 00:08:32
estoy llamando al otro. 00:08:35
Es decir, tengo dos versiones. 00:08:36
Esta y esta. 00:08:42
Tengo dos. ¿Vale? 00:08:43
Esta es la heredada y esta es esta otra. 00:08:45
¿Vale? ¿Pero qué situación 00:08:48
estaba recreando yo? Que yo no 00:08:49
quería esto. Yo no quería esto. Me he equivocado. 00:08:51
Yo creía que estaba sobrescribiendo, 00:08:53
pero me he equivocado y he puesto otra S 00:08:55
y yo tiro con mi aplicación para adelante 00:08:56
con lo cual esto no está 00:08:58
y digo, jolines, pero ¿por qué no funciona? 00:08:59
¿por qué no funciona? ¿por qué está llamando al de la superclase? 00:09:02
¿por qué está llamando al de la superclase? ¿por qué no me funciona? 00:09:04
tú no 00:09:08
no es fácil detectar el error, no es fácil 00:09:08
y el error ha sido que no has puesto la 00:09:10
cabecera igual, con lo cual al compilador le da igual 00:09:12
dice, pues será que estás haciendo otro nuevo 00:09:15
al compilador que más le da 00:09:16
será que estás haciendo otro 00:09:18
bueno, pues si nosotros 00:09:19
nos acostumbráramos a poner 00:09:22
la anotación overwrite 00:09:24
en todos los métodos 00:09:26
que nuestra intención es que sean sobrescritos 00:09:28
si nos acostumbráramos 00:09:31
aquí ya 00:09:33
sí que se produce una validación 00:09:34
porque el compilador 00:09:36
dice, ah, que tu 00:09:38
intención con esto 00:09:40
es sobrescribir un método 00:09:42
de arriba 00:09:44
porque has puesto la anotación, entonces se le hace ya una 00:09:45
validación en tiempo de compilación 00:09:48
ah, espérate, que tu intención 00:09:50
era sobrescribir un método de arriba 00:09:52
va y dice, uy, pues mal vas 00:09:54
porque es que arriba no hay ningún método que se llame así 00:09:57
entonces tú ya 00:09:59
puedes detectar 00:10:01
en tiempo de 00:10:03
compilación, puede detectar que te has 00:10:04
equivocado, y dices, pero ¿cómo puede ser? 00:10:07
pero que sí que hay un método que se llama 00:10:09
mostrar datos, ¿por qué no me dejas sobreescribirlo? 00:10:11
ah, vale, es que no lo he 00:10:13
escrito bien, luego 00:10:15
poner esta anotación 00:10:22
no es que sea obligatorio 00:10:23
y el programa va a funcionar exactamente igual 00:10:25
pero me permite detectar en tiempo de escritura 00:10:27
mía de código, me permite detectar 00:10:30
cosas que a lo mejor estoy haciendo mal 00:10:32
por error y que el compilador no se va a enterar 00:10:34
como ese ejemplo que he dicho antes 00:10:36
llamar a esta mal 00:10:38
entonces yo me creo que estoy sobre escribiendo 00:10:40
la de arriba pero estoy 00:10:42
haciendo otro añadido, otro adicional 00:10:44
y luego cuando 00:10:46
llame al de arriba se va a llamar al original 00:10:48
no al sobre escrito, lógicamente porque el sobre escrito 00:10:50
no existe 00:10:52
y esos errores 00:10:53
no que sean errores 00:10:55
Sino que 00:10:57
Hemos hecho mal la aplicación 00:10:59
Con lo cual la aplicación funciona perfectamente 00:11:01
Pero no está haciendo lo que nosotros queremos 00:11:03
Porque recordad 00:11:05
Hay tres situaciones 00:11:11
La que la facilonga 00:11:12
Errores de compilación, estupendo 00:11:15
Todavía no he entregado mi aplicación 00:11:17
Y es que el compilador me dice que hay algo mal 00:11:19
Yo los arreglo con sus indicaciones 00:11:21
Y sobre todo con mis conocimientos 00:11:23
Pues sus indicaciones pueden ser más confusas 00:11:25
Que otra cosa 00:11:27
Ahora mi aplicación ya no tiene errores de compilación 00:11:28
Creo que está bien 00:11:30
la llevo a fase 00:11:31
de pruebas o lo que sea 00:11:33
ahí ya me pueden salir dos tipos de errores 00:11:35
de ejecución 00:11:37
es decir, yo la arranco 00:11:39
y me sale una excepción, no funciona, errores de ejecución 00:11:41
esos también son buenos 00:11:43
porque los puedo detectar 00:11:45
porque la aplicación no funciona 00:11:48
porque, ¿qué ha pasado? y los arreglo 00:11:49
pero luego ya está el escenario 00:11:51
horrible, que es mi aplicación 00:11:53
no tiene errores de compilación, no tiene errores de ejecución 00:11:55
pero no hace 00:11:57
lo que tiene que hacer 00:11:59
hace otra cosa 00:12:02
pues ese es el problema 00:12:03
y este sería un caso en el cual 00:12:05
ni de error de compilación 00:12:07
ni de error de ejecución funciona 00:12:09
pero lo que hace no tiene nada que ver 00:12:11
con aquello que me han pedido 00:12:13
que es el peor escenario posible 00:12:14
el que tendríamos que evitar 00:12:16
y se evita con un buen análisis 00:12:19
un buen diseño, etc. 00:12:21
y se evita 00:12:25
pues cuando 00:12:29
te retiran el proyecto y dices 00:12:30
o espabilo o me muero de hambre 00:12:33
vale 00:12:35
dudas 00:12:40
no hay dudas, es que para poder ya hacer algo 00:12:43
y hacer alguno de los ejercicios de los que os voy a subir 00:12:50
ya sé que es mucho rollo y mucho hablar 00:12:52
mucho, tenemos que incorporar 00:12:54
lo de los constructores 00:12:56
pero eso es muy rápido 00:12:57
os lo prometo 00:12:59
si de repente quieres transformar 00:13:01
un objeto que tenías un cliente normal 00:13:03
de repente ha hecho tres pedidos 00:13:05
pues entonces, vale, por ejemplo 00:13:07
este cliente C1 00:13:12
que es un cliente normal 00:13:13
pues has verificado cualquier cosa 00:13:15
¿no? entonces imagínate que la aplicación 00:13:18
viene por aquí y ha pasado 00:13:20
algo 00:13:22
que se está cumpliendo 00:13:22
¿eh? 00:13:25
bueno 00:13:30
esto sustituye a esa 00:13:30
condición de pedidos, no sé qué 00:13:34
la que sea y tú le quieres 00:13:35
hacer VIP 00:13:37
pues porque resulta 00:13:39
vamos a poner una condición que dé menos 00:13:41
angustia 00:13:44
resulta que su NIF 00:13:44
empieza 00:13:47
por cero y todos 00:13:50
los que su NIF empieza por cero 00:13:51
te caen tan bien 00:13:53
que los quieres hacer 00:13:55
VIP 00:13:57
pues es que 00:13:58
este no se le puede hacer VIP 00:14:01
tienes que hacer otro 00:14:03
es decir, ¿qué cosa tan rara 00:14:04
tendrías que hacer aquí? 00:14:07
pues te creas un cliente VIP 00:14:09
claro, auxiliar 00:14:11
por ejemplo, ¿vale? y al cliente VIP 00:14:16
no le puedes asignar C1 00:14:18
no puedes, ¿por qué? 00:14:20
C1 es cliente 00:14:23
entonces a un cliente le puedes asignar 00:14:24
un cliente VIP, pero al revés no 00:14:26
entonces, ¿qué tendrías que hacer? 00:14:28
pues tú te instancias aquí 00:14:31
un cliente VIP 00:14:32
No, a un cliente 00:14:33
Un cliente, pero al revés, ¿no? 00:14:42
Claro, es decir 00:14:45
Un animal es un gato 00:14:47
Pero un gato no es un animal 00:14:49
Es decir, ¿no? 00:14:52
Claro, un gato 00:14:53
Encaja dentro del concepto de animal 00:14:55
Pero un animal 00:14:56
No encaja dentro del concepto de gato 00:14:59
Es decir, en un animal tú puedes hacer 00:15:01
New gato, porque gato 00:15:03
Encaja el concepto de animal, pero un gato 00:15:05
No puedes hacer new animal 00:15:07
porque animal no encaja en el concepto de gato 00:15:08
es más grande 00:15:11
entonces cliente VIP no puede asignarle C1 00:15:12
porque C1 es cliente 00:15:15
no puede asignarle algo más grande que él 00:15:17
bueno en ese caso es que son tipos distintos 00:15:19
no es que en este caso 00:15:25
uno está incluido dentro del otro 00:15:27
vale 00:15:28
entonces pues te tendrías que hacer algo nuevo 00:15:28
copiar los datos 00:15:32
aux 00:15:34
Punto nif 00:15:38
Igual a c1 00:15:40
Punto nif 00:15:42
Aux 00:15:43
Punto nombre 00:15:46
Igual a 00:15:47
¿Por qué me deja acceder a las propiedades 00:15:54
A lo bestia? 00:15:56
Ah, ahora se ha enterado, vale, es que como arrastra 00:16:03
Los errores de compilación de antes no se enteraba 00:16:05
Ah no, pero a nif me ha dejado 00:16:06
No, aquí no se ha enterado, aux cliente 00:16:08
Cliente B 00:16:11
Cliente 00:16:14
Protete 00:16:16
Domain, no hereda de 00:16:18
Punto 00:16:28
Nombre 00:16:30
Aux punto 00:16:31
Dirección, claro que este lógicamente 00:16:37
Aux 00:16:40
Punto set 00:16:44
Dirección, con la dirección que sea 00:16:45
Y ahora 00:16:48
Este misterio tan grande 00:16:49
Alguna explicación tendrá 00:16:52
vale, y ahora ya tendrías que ser 00:16:54
hace uno, voy a pisarlo 00:16:56
y ahora hace uno que sea 00:16:58
aus, pues siempre 00:17:00
podías hacer este apaño 00:17:02
vale 00:17:03
es decir, crear una instancia 00:17:05
nueva de cliente vivo, una instancia nueva 00:17:08
esa instancia nueva que 00:17:10
copie los datos, es como 00:17:12
borro el formulario, tengo aquí 00:17:13
mi fichita con el cliente 00:17:16
paz, lo borro 00:17:18
me hago una hoja nueva con los datos 00:17:20
nuevos y al archivo 00:17:22
vale, pero no puedes en la misma 00:17:23
hojita borrar lo que hay 00:17:26
y ponerle otra 00:17:28
cosa, esa hoja la tiras a la basura 00:17:30
te creas una hoja con los datos nuevos 00:17:32
y pin, sustituyes una por la otra 00:17:34
no hay otra, vale, una situación 00:17:36
como esa, vale 00:17:38
el que 00:17:40
yo lo que no pillo 00:17:44
es porque me ha dejado a mi poner aux.nif 00:17:46
con el 00:17:48
protect 00:17:51
¿Pero qué es lo que tú no pillas? 00:17:53
Antes de mirar eso 00:18:00
A ver, aquí esto es una cosa muy particular 00:18:01
Vale 00:18:09
Esto no es una cosa 00:18:11
Que vayas a hacer en una aplicación en general 00:18:14
Habitualmente 00:18:17
Porque normalmente 00:18:18
Si tú tienes clientes 00:18:27
Que se pueden convertir en VIP 00:18:30
tú lo diseñarías de otra manera 00:18:32
que es poniendo un campo boolean que fuera 00:18:34
es VIP y ese campo de boolean lo marcas 00:18:36
a true o false, ¿vale? 00:18:38
es decir que el, si tú consideras 00:18:40
que un cliente puede ser VIP o puede no serlo 00:18:42
y durante el tiempo de vida de tu aplicación 00:18:44
puede ir cambiando, ahora lo soy, ahora no lo soy 00:18:46
ahora lo soy, ahora no lo soy 00:18:48
no harías el diseño, ahora vamos a ver 00:18:49
esto, pero antes déjame que completemos esto 00:18:51
¿vale? es decir, si tú 00:18:54
cuando estudias tu situación, dices 00:18:55
mis clientes, a veces son VIP 00:18:58
a veces no 00:19:00
entonces, frente a esa situación 00:19:01
tú no harías un diseño 00:19:03
en el cual haces dos clases 00:19:05
y dirías, mi cliente 00:19:07
ahora es un objeto de esta y otro es un objeto de esta 00:19:09
otra, sería una cosa un poco rara 00:19:11
lo que harías es, como mis clientes 00:19:13
se caracterizan por ser VIP o no serlo 00:19:15
pues les pongo un boolean 00:19:18
que sea, es VIP o no es VIP 00:19:19
y eso lo va a hacer mucho más 00:19:21
vale, entonces estoy diciendo que 00:19:24
las subclases en el momento en el que se crea 00:19:25
cada objeto debería 00:19:27
determinaste cuál debería ser. 00:19:28
O sea, en una aplicación normal. 00:19:31
Claro, o sea, si tú has hecho un diseño en el cual 00:19:32
tienes esta clase y tienes esta otra, 00:19:34
es porque los objetos 00:19:36
no van a cambiar de tipo. Lo normal es que los objetos 00:19:38
no tengan que cambiar de tipo. 00:19:41
Claro, si tú has hecho una aplicación 00:19:43
en la cual un objeto de repente 00:19:44
ya no le pega a ser de esa clase, 00:19:46
sino de repente debería pasar a ser de otra, 00:19:48
pues cambia el diseño, porque es 00:19:51
muy raro. ¿Vale? 00:19:52
Entonces, si tus clientes 00:19:54
A veces van a ser VIP y a veces no 00:19:56
Con lo cual tienen que cambiar de clase 00:19:58
Pues como de camisa 00:20:00
Pues entonces no hagas dos clases 00:20:03
Sino haz una única clase 00:20:05
Y márcalo con un boolean 00:20:06
¿Vale? Tendría más sentido 00:20:07
Y ahora, tu pregunta 00:20:09
¿No has entendido lo que queríamos hacer aquí? 00:20:12
Sí, más o menos 00:20:15
Tarnapillo 00:20:16
Lo en sí 00:20:17
Lo de 00:20:19
Ah, no, esto es un ejemplo 00:20:19
Esto me he inventado yo 00:20:24
¿por qué le interesa al usuario 00:20:25
un cliente que da normal hacerlo VIP? 00:20:27
Pues porque empezaba por cero y eso le gusta. 00:20:29
Yo qué sé, porque he puesto true 00:20:32
y se ha angustiado, entonces por eso he puesto una condición 00:20:33
cualquiera. O sea, lo que me ha dicho es 00:20:35
y si pasa algo en lo cual 00:20:37
a ti de repente te apetece que un 00:20:39
cliente normal sea VIP, 00:20:41
¿qué harías? Pues tienes que cambiar su tipo 00:20:43
y su tipo no se puede. 00:20:45
Entonces tienes que hacer uno nuevo 00:20:47
de ese otro tipo, copiarle los datos 00:20:49
y sustituir 00:20:51
la referencia C1 por esta. 00:20:53
Entonces, cuando esta llave ha terminado, cuando estamos aquí abajo, C1 sigue vivo, por supuesto, porque C1 está declarado aquí, C1 sigue vivo, pero C1 ahora es un objeto instanciado como cliente VIP. 00:20:55
Si yo ahora hago aquí un instance of cliente VIP, me va a decir true, porque ahora C1 está instanciado como cliente VIP. 00:21:14
y AUX 00:21:20
fue un temporal 00:21:23
que como se declaró localmente 00:21:24
en este bloque 00:21:26
AUX ha estado local en este bloque 00:21:27
entonces en cuanto salgo de la llave 00:21:30
el AUX ya ha desaparecido 00:21:32
y no molesta 00:21:34
pero no es una situación 00:21:35
que normalmente nos veamos 00:21:38
en la tesitura de resolver, cambiar un tío por otro 00:21:40
porque es raro 00:21:42
en relación a lo que estaba diciendo allí 00:21:43
si por ejemplo 00:21:46
hicimos de manera de que 00:21:48
pones lo del bulan es VIP 00:21:49
puedes hacer una condición 00:21:52
en la clase 00:21:55
que sea que si es VIP 00:21:57
declara 00:21:58
si es VIP aparece una variable 00:22:00
no, no, no 00:22:04
no, claro 00:22:05
las propiedades 00:22:08
tienen que ser las mismas 00:22:10
vale 00:22:11
vale, a ver 00:22:12
ahora, el gran misterio 00:22:17
¿por qué 00:22:19
me deja acceder 00:22:21
porque está 00:22:30
en el mismo paquete 00:22:34
vale, vale, es que no 00:22:36
claro, claro, sí, sí, porque está en el mismo paquete, es que normalmente no es lo habitual 00:22:37
que el main esté en el mismo paquete, por ejemplo 00:22:40
lo habitual sería 00:22:42
que nuestro main estuviera aquí fuera 00:22:44
vale 00:22:46
entonces si nuestro main lo movemos aquí fuera 00:22:47
pero protectek no es 00:22:51
para las clases 00:22:52
si, todas las clases 00:22:54
del mismo 00:23:01
Vale, a ver, es que 00:23:02
Sí, sí, sí 00:23:05
Ahora 00:23:08
Lógicamente lo tendría que hacer con el set 00:23:09
Vale 00:23:11
Set nif 00:23:13
Nif 00:23:15
Punto set 00:23:16
Nombre 00:23:26
C1 punto set 00:23:27
Nombre 00:23:32
Ay no, perdón, get nombre 00:23:32
Y ahora c1 punto 00:23:35
Get nif 00:23:43
Vale 00:23:45
Vale 00:23:46
Entonces Protected 00:23:48
Vamos a recopilarlo 00:23:51
Porque aquí tenía yo una pequeña confusión 00:23:52
Como normalmente se hacen diferentes paquetes 00:23:55
Entonces 00:23:57
Ah vale, sí, sí 00:23:59
Protected 00:24:00
A las del paquete 00:24:03
Te deja todas 00:24:07
Y fuera del paquete 00:24:08
Te mete como excepción 00:24:11
Las subclases 00:24:13
Las subclases independientemente del paquete 00:24:14
Donde estén 00:24:22
Pueden ver a esa propiedad 00:24:22
Vale, por ejemplo 00:24:25
Si nosotros 00:24:33
Metiéramos aquí 00:24:34
Por ejemplo he sacado cliente VIP 00:24:37
Solo para probarlo 00:24:39
Para asegurarnos de que lo hemos dicho completamente bien 00:24:40
Cliente VIP lo he sacado fuera 00:24:43
En main 00:24:45
Y cliente VIP 00:24:47
sigue pudiendo ver a nombre 00:24:49
porque es protected, ¿vale? 00:24:51
Cliente ir sigue pudiendo. 00:24:54
Bueno, pues vemos lo de los constructores 00:25:12
y nos vamos, ¿vale? 00:25:14
Que es poquita cosa. 00:25:16
Vale. 00:25:20
Hemos dicho que una clase 00:25:23
que hereda con stents 00:25:24
lo hereda todo menos los constructores, ¿vale? 00:25:27
Pues entonces hay que hacer 00:25:32
constructores específicos. 00:25:33
Por ejemplo, esta clase cliente de aquí 00:25:34
No tiene ahora mismo ningún constructor 00:25:38
Es como si tuviera el constructor por defecto 00:25:42
Pero yo le puedo hacer el constructor con parámetros de toda la vida 00:25:45
Que sería lo ideal 00:25:49
Me hago yo un constructor con parámetros 00:25:50
Este de aquí 00:25:53
Aquí tengo mi constructor con parámetros 00:25:57
vale, recordad que 00:26:06
desde el momento en que hago algún constructor 00:26:08
el constructor por defecto 00:26:11
queda deshabilitado 00:26:13
vale, ahora 00:26:14
cliente VIP 00:26:18
cliente VIP, yo me tendría que 00:26:20
hacer un constructor con todos 00:26:22
sus parámetros 00:26:24
y tiene tres, entonces 00:26:25
el constructor que yo tendría que hacerme con 00:26:28
cliente VIP, que me lo tengo que hacer específico 00:26:30
tiene que tenerlos 00:26:33
todos 00:26:34
String 00:26:35
Nif 00:26:37
String nombre 00:26:38
String dirección 00:26:40
¿Vale? Porque cliente 00:26:44
Tiene 00:26:50
Cliente vip tiene las tres propiedades 00:26:51
Nif, nombre y dirección 00:26:54
¿Vale? 00:26:56
Entonces 00:26:58
Podríamos hacerlo así 00:26:59
Directamente, dis.nif 00:27:02
Igual a nif 00:27:04
Dis.nombre 00:27:06
Igual a nombre 00:27:09
Y dis.dirección 00:27:13
Igual a dirección 00:27:16
¿Vale? 00:27:19
¿Vale? 00:27:21
¿Pero qué ocurre? 00:27:32
Estamos repitiendo código en realidad 00:27:34
Cliente tiene ya aquí 00:27:36
A ver, es que lo he puesto en otro orden 00:27:38
Pero bueno, da igual 00:27:41
lo voy a poner el mismo para que se vea más claro. 00:27:43
Aquí he puesto nombre y nif. 00:27:45
Pues voy a poner aquí también 00:27:48
nombre y nif. 00:27:49
Vale. 00:27:57
Vale, del rojo olvidados. 00:27:59
Ahora lo vemos por qué sale. 00:28:00
Bueno, pues este sería mi constructor 00:28:03
con parámetros. Lo del rojo es al margen de esto. 00:28:04
No tiene nada que ver, lo quitamos. 00:28:07
Mi constructor con parámetros que yo he hecho a mano. 00:28:08
Lo normal no es 00:28:11
repetir todo esto. 00:28:12
Porque aquí tengo solo tres propiedades. 00:28:14
pero imaginaos que yo heredo de una clase 00:28:16
que tiene 50 propiedades 00:28:18
que a su vez 00:28:21
hereda de otra que tiene 20 00:28:22
entonces cada vez que me haga el constructor 00:28:24
me tengo que poner aquí todas otra vez 00:28:26
es una pérdida de tiempo 00:28:28
podría, pero lo habitual es apoyarme 00:28:30
en el constructor del de arriba 00:28:32
aprovechando que el constructor mío de arriba 00:28:36
ya hace estas dos cosas 00:28:39
ya las hace, que hace estas dos 00:28:40
pues hombre 00:28:43
si consiguiera llamarlo de alguna manera 00:28:44
ya tendría esta 00:28:47
parte hecha. Pues, ¿cómo 00:28:49
se llama el constructor 00:28:51
de la superclase? 00:28:52
Con esta llamada. 00:28:55
Constructor 00:29:11
de la 00:29:11
superclase. 00:29:15
¿Vale? 00:29:20
Super es una llamada 00:29:26
que se usa en los constructores 00:29:27
para llamar al constructor de arriba 00:29:29
y así ahorrar código 00:29:31
aquí. Ya ahorras código. Entonces, 00:29:33
este llama al constructor de arriba. ¿El de arriba 00:29:35
qué hace? Coger nombre y 00:29:37
nif y llevarlo a las propiedades que 00:29:39
están ahí ocultas. Pero esta 00:29:41
me falta. Pues así que tengo que hacer a mano. 00:29:43
¿Vale? Así que tengo que hacer a mano. 00:29:46
¿Eh? 00:29:51
Sí, el error es que ya he quitado el 00:29:53
constructor sin parámetros. 00:29:55
¿Vale? Entonces, lo he 00:29:57
quitado. ¿Vale? Pero podemos añadir 00:29:59
todos los constructores que queramos para no retocar 00:30:01
el main, vamos a añadir un 00:30:03
constructor sin parámetros 00:30:05
public cliente 00:30:06
vale, aquí 00:30:09
tengo mi constructor sin parámetros 00:30:11
que lo hemos usado 00:30:14
aquí 00:30:17
vale, pero también hemos usado el sin parámetros 00:30:18
para cliente VIP, pues lo tengo que crear 00:30:21
lo tengo que crear 00:30:23
pues vamos a crear aquí 00:30:25
mi constructor sin parámetros 00:30:26
vale 00:30:33
y ya está 00:30:35
vale, pues recordad esta llamada 00:30:39
porque significa siempre 00:30:52
llamar a la superclase 00:30:54
si yo la llamo sin más, a quien la estoy 00:30:55
llamando es al constructor 00:30:57
¿vale? pero bueno, se puede 00:30:59
usar en otros contextos también, pero por ahora no vamos 00:31:07
a liar 00:31:09
entonces, más o menos 00:31:09
esta es la idea de herencia 00:31:12
sobre la que faltan matices 00:31:15
pero bueno 00:31:17
lo que nos tiene que quedar de herencia 00:31:18
cuidado con la herencia 00:31:23
que es una herramienta 00:31:25
que puede complicar más que otra cosa 00:31:27
¿vale? no se trata de 00:31:30
hacer diseños con jerarquías muy 00:31:31
complejas, muy profundas, no 00:31:33
¿vale? 00:31:35
solamente pues cuando sea necesario 00:31:38
nos ahorre trabajo, solo en ese caso 00:31:39
pero nunca hay diseños 00:31:41
con unos arbolitos ahí de clases 00:31:43
porque eso sería una locura 00:31:45
¿vale? pero sí que nos ahorra 00:31:47
precisamente 00:31:49
el tratar a diferentes objetos que tienen 00:31:51
parte en común, a tratarlos con métodos 00:31:53
separados cada uno de ellos. Eso sí. 00:31:55
¿Vale? 00:31:58
Bueno, pues 00:32:03
bueno, os quedan muchas cosas por ver. 00:32:04
No... 00:32:08
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:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
124.69 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid