Saltar navegación

20260112 Herencia_1 - Contenido educativo

Ajuste de pantalla

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

Subido el 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

¿A lo que íbamos? 00:00:00
¡Leche! 00:00:05
¿Que no sales? 00:00:06
Ah, ahí. 00:00:08
Ah, esto no quería. 00:00:09
Vale, pues siguiente cosita interesante. 00:00:16
De aquí. 00:00:19
Vale. 00:00:22
Bueno, una aplicación son un montón de clases. 00:00:24
¿Vale? 00:00:27
Las clases inevitablemente se relacionan entre sí. 00:00:28
Una forma de relacionarse ya la hemos visto, ya la hemos usado, 00:00:33
que es la relación que se podría llamar de composición. 00:00:39
Es decir, de hecho, en este mismo ejercicio ya hemos visto que nuestra clase cliente tenía dentro, 00:00:44
en este caso era un array, pero podría ser un único objeto. 00:00:57
entonces ya hemos visto que las clases 00:01:01
relacionan entre sí 00:01:04
una forma de relacionarse es la relación 00:01:05
de composición que es 00:01:08
este objeto 00:01:09
tiene a este otro 00:01:11
esto se traduce en 00:01:13
un cliente 00:01:16
tiene 00:01:19
un pedido 00:01:20
¿vale? 00:01:23
es la relación de 00:01:27
composición 00:01:29
entre clases, es decir 00:01:31
como resultado de mi diseño 00:01:37
de estudiar yo mi situación 00:01:39
pues he visto que 00:01:40
uno de mis objetos 00:01:42
está contenido dentro del otro 00:01:44
¿cómo se mapea eso 00:01:46
en la escritura 00:01:49
de mi código? pues que una propiedad 00:01:50
de una clase es 00:01:53
tipo la otra clase 00:01:54
y ya está 00:01:57
y eso no tiene ya para nosotros 00:01:58
a la hora ya de trabajar con ello ningún problema 00:02:00
que quiero yo acceder a los datos 00:02:02
del pedido del cliente C 00:02:05
pues C.P 00:02:07
será su pedido 00:02:09
que además pedido tiene un precio 00:02:10
pues punto precio o punto 00:02:13
el getter, lo que sea 00:02:15
no tiene ningún problema, es lo que hemos estado 00:02:16
usando y esto se puede encadenar 00:02:19
hasta el infinito si precia a su vez 00:02:21
por un objeto de otra clase 00:02:23
y ya está 00:02:25
esa relación es natural, la de que un objeto 00:02:26
tenga otro dentro 00:02:29
y sabemos manejarla. 00:02:30
Bueno, pero hay otra idea en la realidad 00:02:35
que no se puede representar de esta manera, 00:02:37
que necesitaríamos poder representarla también 00:02:42
y que no podemos con lo que sabemos hasta ahora. 00:02:46
Y es la idea de que un objeto puede ser 00:02:51
un caso particular de otro. 00:02:54
a ver, ¿cuándo podemos 00:02:57
necesitar representar 00:03:00
esa idea a nivel de código? representarla 00:03:02
para poder hacer aplicaciones que trabajen 00:03:04
con esa idea y programar, pues por 00:03:06
ejemplo, si usamos 00:03:08
esta misma 00:03:10
este mismo 00:03:11
caso que estamos haciendo 00:03:13
esta misma aplicación que tenemos en la 00:03:15
cabeza ahora mismo de clientes y pedidos 00:03:18
pues nada, mi aplicación ya está hecha, está 00:03:20
funcionando, está todo estupendo ya 00:03:22
ya la tengo ahí, pero de repente 00:03:24
el que usa mi aplicación 00:03:26
y viene y me dice 00:03:28
¡Ay! 00:03:30
He metido un nuevo 00:03:32
concepto en mi negocio 00:03:34
y el nuevo concepto de mi negocio 00:03:36
es que ahora tengo 00:03:38
clientes especiales, a los que 00:03:40
trato de forma especial 00:03:42
entonces son clientes distintos 00:03:43
una cosa será el cliente normal 00:03:46
el cliente genérico, tengo a mi cliente 00:03:48
genérico 00:03:50
al cliente 00:03:51
tal y como está en la aplicación 00:03:56
pero es que acabo de incorporar 00:03:59
la posibilidad de tener clientes 00:04:01
especiales porque han 00:04:03
acumulado un volumen de compras de no sé qué 00:04:04
y esos clientes los trato 00:04:07
de forma especial porque les mando 00:04:09
una felicitación en navidad y una cesta 00:04:10
de navidad, entonces esos clientes 00:04:13
los tengo que distinguir de los 00:04:15
otros porque necesito 00:04:17
más datos para ellos, pues como 00:04:19
la dirección de su casa 00:04:20
el nombre de su perrito 00:04:22
lo que sea, entonces 00:04:25
uno diría, bueno pues 00:04:27
necesitamos otra clase 00:04:28
porque los clientes especiales 00:04:30
se caracterizan por un conjunto de 00:04:33
propiedades distintas 00:04:35
entonces si de repente me aparece una entidad 00:04:36
que necesita 00:04:39
otras propiedades distintas 00:04:41
pues es otra clase 00:04:42
bueno, vale, pues entonces 00:04:44
podríamos hacer cliente general 00:04:47
y cliente 00:04:48
especial, el cliente 00:04:52
este 00:04:54
esta con sus propiedades 00:04:55
y esta con sus propiedades 00:04:58
y yo hago mi aplicación así 00:05:00
vale, pues ya está 00:05:02
y así puedo tirar mi aplicación 00:05:04
pero a ver, es un poco 00:05:05
absurdo, porque enseguida me doy 00:05:08
cuenta de que estoy duplicando información 00:05:10
porque las propiedades 00:05:12
que tiene aquí el cliente 00:05:14
también las tiene este otro 00:05:16
otra cosa es que tenga más 00:05:17
que además tenga más, pero las que 00:05:19
tiene, él las tiene 00:05:22
Entonces, automáticamente nos damos cuenta de que ahí surge una relación 00:05:23
Que ojalá Java y los lenguajes de programación me permitieran reflejarla 00:05:28
De tal manera que me facilitara la escritura del código 00:05:34
Bueno, pues ¿qué relación ha surgido aquí? 00:05:37
Ha surgido lo que en lenguajes de programación se llama una relación de herencia 00:05:40
la relación de herencia 00:05:44
yo la identifico 00:05:50
cuando puedo enunciar 00:05:52
la siguiente frase 00:05:54
esta clase 00:05:56
es esta otra 00:05:58
cuando a la frase 00:06:00
x es y 00:06:03
cuando esta frase tiene sentido 00:06:06
entonces automáticamente aparece 00:06:08
una relación de herencia y eso lo tengo que 00:06:10
transformar en mi código 00:06:12
programando en coherencia con eso 00:06:14
entonces, cliente VIP 00:06:16
es cliente genérico 00:06:19
si, un cliente VIP es cliente genérico 00:06:21
tiene más cosas, pero cliente genérico 00:06:23
es, porque, ¿qué significa ser 00:06:26
cliente genérico? que todo lo que hay aquí 00:06:27
lo tiene, todo lo que hay aquí lo tiene 00:06:29
tiene más cosas, pero 00:06:32
es cliente genérico, ¿no? el ejemplo 00:06:33
típico que 00:06:35
se pone en los libros cuando se estudia esto 00:06:37
es, tú tienes una clase 00:06:39
animal porque trabajas con animales 00:06:41
y de repente tu aplicación se 00:06:43
amplía y quieres tratar de forma diferente a los 00:06:45
gatos, a los perros y a los ratones 00:06:47
pues entonces 00:06:49
tienes la clase 00:06:51
gato, la clase perro, la clase 00:06:54
ratón y tú puedes decir 00:06:55
oye, un gato es un animal 00:06:57
claro que un gato es un animal 00:07:00
con lo cual mi clase gato 00:07:01
es heredera de la 00:07:03
clase animal, que eso se va a 00:07:05
traducir en como programa 00:07:07
mi clase perro es heredera 00:07:09
de la clase animal, porque el perro es 00:07:11
un animal, pues aquí igual 00:07:13
mi cliente VIP 00:07:15
es un cliente genérico, sí, esa frase 00:07:17
tiene sentido, pues entonces 00:07:20
aparece esta relación de herencia 00:07:21
y eso tiene implicaciones a la hora 00:07:23
de la escritura del código que van a 00:07:26
facilitar, van a facilitar 00:07:27
el desarrollo de la aplicación 00:07:29
ese es el objetivo, que la 00:07:31
facilite de alguna manera, porque si no 00:07:33
el identificar esta relación luego no tuviera 00:07:38
implicaciones a la hora de desarrollar la aplicación 00:07:39
pues me hago dos clases separadas y ya está 00:07:42
pero claro que las tiene, tiene muchísimas 00:07:44
el identificar, las tiene un montón 00:07:46
entonces esta relación de aquí 00:07:47
lógicamente no es una relación 00:07:52
de herencia, porque uno no puede decir 00:07:54
oye, un pedido 00:07:56
es un cliente, no 00:07:58
un pedido no es un cliente 00:08:00
con lo cual la clase pedido nunca 00:08:02
heredaría de cliente 00:08:04
si yo hago un diseño 00:08:06
en la cual la clase pedido herede 00:08:07
de cliente con las herramientas de herencia 00:08:10
que ahora veremos 00:08:12
y empiezo a tirar de ahí 00:08:14
me monto un lío y hago una aplicación 00:08:15
al final que es que es imposible arreglar eso 00:08:18
porque el diseño inicial ya está mal 00:08:20
porque un pedido no es un cliente 00:08:22
luego la relación no es de herencia 00:08:24
sino que es la de composición 00:08:26
que es la de un cliente 00:08:28
tiene un pedido 00:08:30
que es otra cosa, una cosa es tener 00:08:32
y otra cosa es ser 00:08:34
son dos cosas distintas 00:08:35
entonces cuando yo identifico 00:08:37
X tiene ahí 00:08:39
pues habrá una propiedad de clase Y 00:08:41
dentro de la clase X, que es lo que hemos hecho hasta ahora 00:08:44
si yo identifico 00:08:46
X es Y 00:08:48
pues ahí no, ahí no habrá una propiedad 00:08:49
X dentro de la clase Y 00:08:52
ahí lo que habrá será una relación entre clases X e Y 00:08:53
que me va a facilitar 00:08:56
el trabajo, ¿vale? 00:08:58
pues aquí perfectamente 00:09:00
está esa relación, un cliente Y que es un cliente genérico 00:09:01
¿vale? 00:09:04
¿eso en qué se traduce? 00:09:06
escrito así de mala manera, luego ya lo escribimos 00:09:07
ahí mejor. Vale, pues yo aquí tendría 00:09:10
mi clase cliente 00:09:15
genérico 00:09:22
pues con sus propiedades 00:09:24
por ejemplo 00:09:26
vamos a suponer que tiene solamente el NIF 00:09:28
es lo único que nos interesa del cliente genérico 00:09:30
y lo que pueda. Vale 00:09:32
y mi aplicación 00:09:34
ha trabajado con esto 00:09:36
ahora es cuando yo he decidido que la voy a 00:09:37
ampliar porque ahora hay clientes especiales 00:09:40
pues nada 00:09:42
entonces yo añado otra clase 00:09:44
añado mi clase 00:09:46
es que esto pinta cada vez con el color 00:09:48
que le da la gana según la 00:09:50
la inclinación 00:09:52
si está gordo o está delgado 00:09:54
vale, entonces digo 00:09:56
a ver, cliente 00:09:58
es una entidad nueva que ha aparecido 00:10:00
en la ampliación de mi aplicación 00:10:02
una entidad nueva 00:10:04
vale, pero yo me doy cuenta 00:10:05
es lo importante, me doy cuenta de que hay 00:10:07
una relación de herencia 00:10:10
entre esta 00:10:11
y esta 00:10:13
hay una relación de herencia 00:10:14
me acabo de dar cuenta, menos mal que me he dado cuenta 00:10:17
porque gracias a eso la aplicación va a cobrar 00:10:19
mucho más sentido 00:10:21
entonces al darme cuenta que un cliente 00:10:22
VIP es un cliente genérico 00:10:25
¿qué añado yo? pues añado aquí 00:10:27
antes de la llavecita en este hueco 00:10:29
añado un 00:10:31
extends 00:10:33
cliente G 00:10:34
entonces con esto 00:10:39
hago constar 00:10:43
la relación de herencia entre esta y esta 00:10:45
la hago constar 00:10:48
por traducción de Stents 00:10:49
es lo que por muchas veces 00:10:52
podréis leer cliente VIP 00:10:53
extiende a cliente G 00:10:56
realmente 00:10:58
es cliente VIP hereda de cliente G 00:11:00
pero bueno, por la traducción normal 00:11:02
a veces se dice que cliente VIP 00:11:04
extiende a cliente G, es lo mismo 00:11:05
significa lo mismo 00:11:08
¿por qué no te he dicho eso? 00:11:09
no, pues que si 00:11:12
veis vídeos, veis cosas, veis rollos, 00:11:13
pues muchas veces, a veces se dice 00:11:16
que esta clase extiende a esta 00:11:18
porque se traduce directamente el 00:11:20
estense. Entonces, cuando se dice 00:11:22
eso, lo que se quiere decir es que esta clase hereda 00:11:24
de esta. Vamos, que es 00:11:26
la idea sinónima. Dime. 00:11:27
No, solo puedes 00:11:35
heredar de una clase. 00:11:37
Claro, sí, 00:11:40
lo que puedes es hacer muchos casos 00:11:41
de clientes. Cliente VIP, 00:11:43
cliente moroso, 00:11:45
también hereda de cliente. 00:11:47
cliente es súper guapo, también hereda 00:11:48
de este, los clientes que quieras, 00:11:50
¿vale? Pero 00:11:53
cada clase, cada uno, 00:11:54
será un caso particular. 00:11:56
Pero, una 00:11:59
clase solamente 00:12:00
puede heredar de otra. 00:12:02
No puede ser un caso particular 00:12:05
de varias clases distintas. 00:12:06
Lo cual es un problema. 00:12:09
Es un problema, un segundín. 00:12:11
Es un problema porque hay realidades 00:12:12
que yo quiero manejar 00:12:14
en las cuales un concepto puede 00:12:16
ser un caso particular de muchas cosas no por ejemplo yo puedo tener mi aplicación o en mi 00:12:18
taller mecánico pues yo que se tiene la idea de pieza y luego tiene la de pieza pues para hacer 00:12:23
las reparaciones y luego la de producto en la parte de ventas entonces a lo mejor tengo una 00:12:29
rueda y una rueda es una pieza dentro de la parte de mi aplicación que gestiona reparaciones pero 00:12:34
una rueda también es un producto dentro de la parte que gestiona entonces dijo pieza no puede 00:12:40
tener todo lo de perdón rueda no puede tener todo lo de pieza y todo lo de producto pues no no puede 00:12:45
con lo cual no puede con esta relación de herencia pero sí con la siguiente relación que veremos que 00:12:54
es la de implementación pero eso es otra cosa con la adherencia tal cual sólo se puede dar de una 00:13:03
clase. Dime. 00:13:08
¿Y si haces una clase de cliente VIP? 00:13:10
Puedes. La herencia puede ir hasta el 00:13:14
infinito. Puedes tener nietos, 00:13:16
tratar a nietos. Puede haber 00:13:18
cliente VIP 00:13:20
extranjero. Pues cliente 00:13:22
VIP extranjero hereda 00:13:25
cliente VIP. 00:13:26
Puedes hacer estés cliente VIP. 00:13:28
No. 00:13:32
Lo que no puedes es 00:13:33
una clase, después de su estés 00:13:34
solo puede tener una. Es decir, 00:13:36
Ah, vale, que no puede. 00:13:38
Claro. 00:13:39
Vale, vale. 00:13:39
Es decir, la relación de herencia, tú tienes aquí esta clase C, ¿vale? 00:13:40
De la clase C pueden heredar muchas, C1, C2, C3, 00:13:45
pero cada una de ellas solo puede tener una superclase que se llama. 00:13:49
Esto es lo que se llama superclase y estas las subclases. 00:13:54
Cada una de ellas sería C1 estén C, pero solo estén C, 00:14:01
solo puede heredar de una. 00:14:06
C2 extens C, pero C2 solo de una 00:14:07
C3 extens C, pero C puede tener 00:14:10
tantos hijos como quiera 00:14:12
¿vale? pero a su vez 00:14:14
cada una de estas, que son subclases 00:14:16
de esta porque heredan 00:14:18
pueden tener otra subclase a su vez 00:14:19
entonces aquí podría haber una C4 00:14:22
y esta C4 extens C2 00:14:24
ningún problema 00:14:26
que a su vez C2 extens C 00:14:27
la relación jerárquica 00:14:30
puede ir 00:14:32
funciona así y se puede extender hasta el infinito 00:14:33
otra cosa es que 00:14:36
tiene sentido hacer una relación de clases 00:14:38
no, porque la idea es 00:14:40
con esto facilitar 00:14:43
el desarrollo, no complicarlo 00:14:45
y normalmente cuando uno hace una aplicación 00:14:46
pues hombre 00:14:49
no está representando algo 00:14:50
tan absolutamente complejo 00:14:53
una relación tan compleja, no hay necesidad 00:14:55
dime 00:14:57
pero la subclase, por ejemplo la C4 00:14:57
¿le daría también las cosas de la C4? 00:15:01
claro, la C4 00:15:03
heredaba lo de C2, ahora ya vemos en detalle 00:15:05
que se hereda y cómo se hereda, pero vamos 00:15:07
avanzamos, C4 coge 00:15:09
todo lo de C2 más lo añadido 00:15:11
y como C2 ya había 00:15:13
cogido todo lo de C, pues 00:15:15
entonces este a través de su padre 00:15:17
pues coge lo de su abuelo 00:15:18
¿vale? 00:15:19
Sí, en los diseños 00:15:30
de bases de datos, esta idea 00:15:32
también está, claro 00:15:35
en los modelos de entidad-relación 00:15:36
también está la relación de herencia 00:15:38
¿no? 00:15:40
vale, pues entonces 00:15:49
entonces yo me he dado cuenta 00:15:50
identificado afortunadamente para 00:15:56
el bien del éxito de mi aplicación 00:15:58
que un cliente 00:16:01
VIP es un cliente genérico 00:16:03
entonces en lugar de hacer una clase para él 00:16:04
de cero 00:16:06
hago un hereda cliente genérico 00:16:07
bueno, ya he puesto el 00:16:10
extens, ahora, ¿qué implicaciones tiene 00:16:12
que yo ya he puesto el extens? 00:16:14
pues las implicaciones que tiene 00:16:17
es que todas las propiedades que estén 00:16:18
aquí, todas 00:16:20
es como si estuvieran aquí 00:16:22
yo no las veo físicamente 00:16:24
ni tengo que escribirlas 00:16:26
pero es que están directamente 00:16:28
¿vale? no tengo que 00:16:30
escribirlas, todas las propiedades 00:16:32
del cliente genérico están aquí, entonces yo 00:16:34
me limito a escribir 00:16:36
lo único que quiera añadir 00:16:38
pues por ejemplo su dirección postal 00:16:40
para enviarle un regalito 00:16:42
pues ya está 00:16:43
añado lo nuevo 00:16:46
y se acabó 00:16:48
y no solo pasa con las propiedades 00:16:50
que todas tal cual 00:16:58
las que estén aquí es como si estuvieran aquí 00:17:00
¿vale? 00:17:03
sino que los métodos también 00:17:05
si yo aquí tengo 00:17:07
métodos de cualquier tipo 00:17:09
lo que sea 00:17:10
pues esos métodos 00:17:16
tal cual es como si estuvieran aquí 00:17:20
no tengo que escribirlos, los mismos métodos 00:17:21
es como si se hiciera 00:17:23
un copia y pega 00:17:25
¿vale? y es realmente 00:17:27
un copia y pega, no es que el 00:17:29
cliente VIP cuando 00:17:31
llame a mostrar o a dirección 00:17:33
esté llamando a mostrar dirección de un cliente 00:17:35
genérico, no, no, no, no 00:17:37
los clientes VIP serán unos objetos cliente VIP 00:17:39
cliente genérico, otros objetos 00:17:41
distintos 00:17:43
lo que pasa es que aquí 00:17:44
es como si hubiéramos hecho un copia y pega 00:17:46
aunque yo no lo vea 00:17:48
¿vale? 00:17:50
que es lo único que nos hereda 00:17:52
los constructores 00:17:55
este es sus métodos constructores 00:17:58
esto 00:18:03
nos hereda 00:18:04
aquí hay que hacerle sus métodos constructores 00:18:06
específicos o dejar el método 00:18:09
por defecto, lo que sea 00:18:11
el método constructor nos hereda 00:18:12
¿Y el constructor aquí cómo sería? 00:18:14
¿Le pasaría los parámetros? ¿Sería un cliente G? 00:18:20
Le tienes que pasar todos 00:18:23
Todos, porque este 00:18:24
Aunque yo solo vea DIR 00:18:26
Este tiene DIR y NIF 00:18:28
Luego a este constructor, si yo quiero hacer el constructor con parámetros 00:18:29
Hay que pasarle todas sus propiedades 00:18:32
Esta, esta, todas 00:18:34
¿Pero podría tener un constructor que fuese cliente G 00:18:36
Y dirección? Porque digamos que 00:18:38
Tengo un cliente G 00:18:40
Que ha hecho 100 pedidos 00:18:42
A partir de los 100 pedidos se vuelve VIP 00:18:43
No, pero no 00:18:45
Claro, pero tú no puedes 00:18:47
Cambiar el tipo de una variable 00:18:49
Una vez creada 00:18:51
Lo que tendrías que hacer en un caso así es 00:18:52
Ese objeto cliente G 00:18:55
Te crearías un objeto nuevo cliente B 00:18:57
Copiarías los datos 00:18:59
De uno en otro 00:19:01
Y ya está, y ese desaparecería hasta que lo 00:19:02
Haciera el colector de basura 00:19:05
O sea, una variable ya instanciada 00:19:06
Sea entera, sea de un objeto 00:19:08
No puede cambiar su tipo 00:19:10
Entonces, si tú un cliente 00:19:12
Lo has instanciado como cliente genérico 00:19:15
va a ser cliente genérico siempre 00:19:17
si tú los datos de ese cliente 00:19:18
los quieres volcar ahora ya 00:19:21
en un objeto cliente VIP porque ha cambiado 00:19:22
te tienes que instanciar un cliente VIP 00:19:24
volcar en él sus datos 00:19:27
y ya está, y trabajar a partir de ahí 00:19:28
con ese 00:19:31
¿cómo funcionaría 00:19:31
lo que establece 00:19:34
que pasas de cliente G a cliente VIP? 00:19:39
es que no pasas 00:19:42
no pasas 00:19:43
no pasas, tú tienes 00:19:44
tu aplicación tendrá objetos 00:19:47
cliente genérico y objetos 00:19:49
cliente VIP. Y eso está en infinito. 00:19:52
No se convierte uno a otro. 00:19:54
Pero si un cliente VIP, por ejemplo, 00:19:56
se establece cuando un cliente 00:19:58
ha hecho un 20%... Vale, es justo 00:20:00
lo que está diciendo él. Bueno, pues si tú 00:20:02
ese objeto lo has instanciado como cliente 00:20:04
genérico y a partir 00:20:06
de ese momento quieres que sea cliente VIP, 00:20:07
no puedes cambiar el tipo de dato. 00:20:10
Una variable, sea variable objeto 00:20:12
o variable primitiva, que ya está declarada, 00:20:14
no puede cambiar 00:20:16
el tipo de datos, jamás. 00:20:17
Entonces, tendrías que crearte un objeto 00:20:19
cliente VIP, volcar los datos 00:20:21
de uno en otro y trabajar a partir de él 00:20:24
con él, ¿vale? 00:20:25
Entonces, la pregunta, 00:20:28
antes de ver ya los detalles de la aprobación de todo esto, 00:20:29
la pregunta 00:20:32
interesante de esto es, 00:20:33
aparte de para ahorrarme el copia 00:20:36
y pega, que tampoco es que me ahorre 00:20:38
tanto un copia y pega, 00:20:40
¿qué ventaja saco de esto? 00:20:42
Pues, sacamos 00:20:45
una ventaja enorme. 00:20:46
Es que es el núcleo, en realidad, 00:20:47
de la programación. 00:20:49
Una ventaja enorme. 00:20:51
¿Eh? 00:20:52
No, ahorramos memoria porque los objetos son los mismos. 00:20:55
¿Cómo que tienes nulo en 50 minutos? 00:21:06
A ver, pero los objetos que tienes en memoria 00:21:11
son los mismos. 00:21:13
Tú es que esto lo puedes ver 00:21:15
como si hubieras hecho dos 00:21:17
clases distintas y en lugar 00:21:19
de hacer herencia, hubieras 00:21:21
hecho un copia y pega. Es lo mismo. 00:21:23
Con lo cual, en memoria, los objetos 00:21:25
que tienes son los mismos. Que tienes 20 BIP 00:21:27
y tres genéricos. Me da igual que 00:21:29
a la hora de declarar el código yo haya puesto 00:21:31
tendrás tres clientes genéricos, 00:21:33
tres BIP. Los objetos son los mismos. 00:21:35
O sea, no ahorras nada de memoria. 00:21:37
No ahorras nada. 00:21:39
No, los dibujos que tienes son los mismos. 00:21:42
Lo que pasa es que tú no los has 00:21:44
escrito aquí físicamente. 00:21:45
Pero cliente VIP, o sea, no es que cliente VIP esté apuntando a los de un cliente genérico, no. 00:21:47
Son dos objetos distintos. 00:21:53
Cuando tú instancias un cliente VIP, instanciarás una cosa con sus dos campos. 00:21:55
Como si hubieras puesto aquí string if igual. 00:22:02
Cuando instancias cliente genérico, instanciarás una con un campo. 00:22:04
Que ahora instancias otro cliente VIP, otro con dos campos. 00:22:08
O sea, no estás ganando nada en cuanto a memoria. 00:22:11
No, pero me refiero, o sea, como directamente. 00:22:13
¿Cómo que no? Ah, vale, ya te entiendo. Claro, que si todos los hiciéramos así, porque no tuviéramos esta, habría un montón de objetos en los cuales este campo no serviría para nada. 00:22:19
Claro, para optimizar el diseño, claro, lógicamente. Para optimizar un poquito, sí. Pero sí, no estaba pensando en eso. Por supuesto, una herramienta es, hago un diseño más fiel a la realidad, lógicamente. 00:22:32
a un diseño más fiel 00:22:45
pero me estaba refiriendo a otra cosa 00:22:47
silencio y nos vamos 00:22:49
me refería a 00:22:52
si resulta que esta clase 00:22:53
hereda de esta otra 00:22:56
ahora yo ya me pongo a hacer mi aplicación 00:22:57
mi aplicación va a trabajar con clientes 00:22:59
entonces 00:23:02
vale, mi aplicación va a trabajar 00:23:03
con clientes, entonces ahora uno diría 00:23:12
uff, que rollo 00:23:14
ahora tengo dos tipos de clientes 00:23:15
tan rollo, ves que se duerme 00:23:17
vale, uno diría, ¿qué rollo? 00:23:19
tengo dos tipos de clientes 00:23:21
voy a tener que hacerme 00:23:23
dos arrays 00:23:25
un array clientes 00:23:27
G con mis 00:23:31
clientes genéricos 00:23:33
y menudo rollo 00:23:36
otro array 00:23:37
clientes B 00:23:39
con mis clientes normales 00:23:41
entonces diríais, pues 00:23:43
solamente por evitarme un copia y pega 00:23:44
a la hora de escribir código, ya ves 00:23:48
tu que tontería, he complicado 00:23:50
la aplicación porque tengo dos datos en paralelo 00:23:51
los que son así y los que son así 00:23:54
habrá algunos que estarán 00:23:56
instanciados como este 00:23:58
y habrá otros que estarán instanciados como este 00:23:59
entonces, menudo 00:24:01
rollo, pues 00:24:04
no, porque gracias a que 00:24:05
esta clase hereda 00:24:08
de esta otra 00:24:10
objetos de la clase 00:24:11
cliente VIP 00:24:14
se pueden guardar en referencias 00:24:15
de la clase cliente G 00:24:19
es decir 00:24:21
y este es el núcleo en realidad 00:24:22
de la programación orientada a objetos 00:24:25
en una referencia de tipo cliente G 00:24:27
y eso ahora lo vemos 00:24:31
en detalle 00:24:33
en una referencia de tipo clientes G 00:24:35
yo por supuesto 00:24:42
como hemos visto hasta ahora 00:24:44
yo me puedo hacer un cliente G, está claro 00:24:47
esto es lo que hemos visto 00:24:50
pero al heredar cliente B de cliente G 00:24:51
en un tipo de dato o referencia 00:24:54
de tipo clientes G 00:24:58
también 00:24:59
puedo guardar, si quiero 00:25:01
un objeto 00:25:03
instanciado como cualquiera 00:25:05
de sus herederos 00:25:08
es decir, esto también lo puedo 00:25:09
hacer, porque esta clase 00:25:15
hereda de esta 00:25:17
entonces 00:25:19
esa es la potencia que tiene 00:25:23
y de esta tontería 00:25:26
ha surgido todo el mundo 00:25:27
que ha permitido 00:25:30
que la programación de entradas de objetos 00:25:31
haya triunfado 00:25:34
cosa que 00:25:35
tiene menos implicaciones 00:25:36
entonces, ¿qué significa esto? 00:25:38
¿este objeto cómo se ha creado? 00:25:41
como cliente VIP, está claro 00:25:43
porque su NEO es cliente VIP 00:25:45
con lo cual tiene sus dos propiedades 00:25:46
este no, este se ha creado 00:25:49
como cliente genérico, luego solo tiene una 00:25:51
pero 00:25:53
la referencia 00:25:54
que lo apunta 00:25:57
la referencia que lo apunta como está declarado 00:25:58
en ambos casos 00:26:01
puede ser esta, ¿por qué? 00:26:02
porque esta hereda de esta 00:26:05
otra, entonces esto se me permite 00:26:07
se me permite 00:26:09
aunque el objeto 00:26:11
sea así 00:26:13
vale, pues eso 00:26:13
que me permite que yo 00:26:17
declaro mi variable o mi 00:26:19
array, depende de lo... Y luego 00:26:21
ya, a la hora de crear los 00:26:23
clientes, puedo decidir 00:26:25
si es VIP, si es genérico, 00:26:27
me da igual. La referencia 00:26:29
es de la superclase. 00:26:30
La referencia es de la superclase. 00:26:32
Luego, el objeto en 00:26:35
concreto puede ser 00:26:37
de cualquiera de las subclases. 00:26:39
De cualquiera. Entonces, yo 00:26:41
tengo un único array de clientes genéricos 00:26:43
y luego, a la hora de ir 00:26:45
metiendo cada dato, meto el que me dé 00:26:46
la gana, pero todos metidos 00:26:48
en un único array. 00:26:50
¿Vale? Entonces, 00:26:53
repito y ya nos vamos. 00:26:57
Cuando tú tienes una variable, 00:27:00
una referencia, recordad que 00:27:01
las variables de objeto le llamamos referencias, 00:27:03
declarada como 00:27:06
una clase, 00:27:07
puedes meter objetos en ella. 00:27:09
Tanto de esa 00:27:12
clase, por supuesto, como 00:27:13
de cualquiera de las subclases que tenga. 00:27:15
De cualquiera. 00:27:18
De un array de animales. 00:27:20
Puedes meter perros, gatos, leones, lo que te dé la gana, siempre y cuando todos ellos se hereden, ¿vale? En una referencia o clase de vivienda puedes meter chalet, piso, ático, sótano, lo que quieras, ¿vale? 00:27:21
Bajo el paraguas de una idea, bajo el paraguas de una idea, puedes meter todos los casos diferentes que quieras, ¿vale? 00:27:43
No tienes que hacer variables separadas para cada uno o arrays separados para cada uno porque sería una locura. 00:27:53
Realmente, para cada idea hay muchos casos concretos, pues de eso se trata, de hacer un paraguas y luego yo meto cada caso, 00:28:01
meto dentro de ese paraguas todos los casos particulares. 00:28:09
bueno, pues ahora luego después vemos 00:28:15
todo esto 00:28:18
porque es interesante 00:28:20
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:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 24″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.75

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid