Saltar navegación

20250116 RepasoHerencia_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 16 de enero de 2025 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

Para los descontextualizados, teníamos esta aplicación que usamos de ejemplo el otro día para volver a revisar los conceptos de herencia que igual el lunes no habían quedado suficientemente claros y esta aplicación de ejemplo, para que la continuemos ahora y no la dejemos a medias, tenía esta arquitectura que hemos dicho, dos tipos de clientes como comparten propiedades como DNI, nombre y conjunto de pedidos, 00:00:00
Hacíamos una única superclase, estándar, y luego ya cliente online a través de esta cláusula, 00:00:30
Stents, se convierte en otra clase, por supuesto, otra clase distinta, 00:00:39
pero al heredar de cliente automáticamente ya establecemos una relación del tipo 00:00:45
un cliente online es un cliente. 00:00:49
Las relaciones de herencia en los lenguajes de información y entrada de objetos 00:00:53
se programan, como veis, de forma muy sencilla 00:00:58
y nos abren un montón de posibilidades 00:01:00
como ya vimos el otro día. 00:01:03
Curiosamente, las relaciones que no se programan 00:01:07
en programación de entradas de objetos 00:01:11
son las relaciones de composición, 00:01:12
como un cliente tiene un producto, 00:01:15
un cliente tiene un nombre, esas no se programan. 00:01:17
Y esas son las que sí se programan en el modelo relacional. 00:01:20
Es decir, están contrapeadas. 00:01:24
El modelo relacional programa de forma muy estricta las claves ajenas de la tabla pedido 00:01:25
Habrá una clave ajena a tabla cliente para saber cuál es el cliente que ha hecho un pedido 00:01:34
Pero eso no se programa aquí 00:01:39
Lo más que se puede hacer es meter en pedido un objeto cliente para saber cuál es su cliente 00:01:42
Y sin embargo las que sí que se programan aquí que son las de herencia 00:01:47
de forma tan sencilla 00:01:50
como con el Stents y que nos abren 00:01:52
todo eso que ya vimos 00:01:54
el otro día, pues en el modelo 00:01:56
relacional no están las relaciones de herencia. 00:01:58
Entonces, claro, porque han sido dos 00:02:00
desarrollos que han ido por libre. ¿Cuál es el problema? 00:02:02
Que las aplicaciones trabajan 00:02:04
con bases de datos aquí. 00:02:06
Entonces hay que poner 00:02:08
un intermediario que los ponga de acuerdo. 00:02:10
Pues de esos intermediarios 00:02:13
es de lo que se trata el módulo de segundo. 00:02:14
¿Vale? Bueno. 00:02:16
Pues 00:02:19
no necesito venderla 00:02:19
ya se vende sola 00:02:23
no me hace falta 00:02:25
bueno pues entonces 00:02:26
poniéndole stands cliente ya sabíamos lo que conseguíamos 00:02:29
que todas las propiedades que había 00:02:31
aquí es como si hubiéramos 00:02:33
hecho un copia y pega aquí 00:02:35
están ahí 00:02:37
en este caso en particular como aquí 00:02:37
están con el private 00:02:41
porque las hemos puesto privadas porque es la 00:02:42
forma habitual de programar 00:02:45
una clase entidad 00:02:47
La forma habitual de programar una clase entidad, recordad que es, pongo las propiedades como privadas, eso significa que no puedo acceder a ellas, escribir, simplemente escribirlas, para acceder a ellas, para leer o sobre escribirlas, en ningún sitio que no sea extra clase, eso es lo que sabemos que significa poner el modificador. 00:02:49
entonces como habrá otras clases 00:03:11
que sí que quieran acceder al DNI de cliente 00:03:14
al nombre de cliente 00:03:17
como habrá otras clases que sí que quieran 00:03:18
y no van a poder por este modificador 00:03:20
por eso hacíamos los GET y los SET 00:03:22
el GET 00:03:25
al ser ya público 00:03:26
sí podrá ser invocado desde otras clases 00:03:27
y el GET me permitirá recuperar 00:03:30
el valor de esta propiedad 00:03:32
y el SET de nuevo 00:03:33
al ser público 00:03:35
podrá ser invocado desde otra clase 00:03:37
y el SET que me permitirá 00:03:39
sobrescribir el valor 00:03:41
de esta propiedad 00:03:44
entonces separo el permiso de lectura 00:03:45
de una propiedad 00:03:48
del permiso de escritura 00:03:49
a través de estos métodos 00:03:50
y aquí prohíbo el acceso 00:03:52
directamente a la propiedad por poner el privado 00:03:55
esto insisto es un convenio 00:03:57
una forma de hacer las clases entidad 00:03:59
¿vale? pero que más o menos todos respetamos 00:04:01
en este caso de la herencia 00:04:04
la implicación que tiene 00:04:06
es que el modificador al ser privado 00:04:07
aunque cliente, que hereda de cliente 00:04:09
tenga aquí, que nosotros 00:04:13
no lo vemos, pero es como si físicamente 00:04:14
tiene aquí esto, la tiene 00:04:16
aunque no la veamos, porque se ha hecho un copia y pega 00:04:18
la tiene ahí, aunque no la veamos 00:04:20
no podemos 00:04:22
escribirla, no podemos usarla 00:04:23
si yo aquí quiero hacer un mostrar datos 00:04:26
que me muestre la propiedad DNI 00:04:28
¿vale? 00:04:30
pues DNI es una propiedad que existe 00:04:33
en esta clase, claro que existe 00:04:36
porque aquí hay un copia y pega invisible 00:04:38
de aquí, claro que existe 00:04:40
pero 00:04:42
al estar puesta como privada 00:04:43
aquí, el compilador 00:04:45
te dice, no, no, no, no, es privada 00:04:48
no puedes ni siquiera escribir 00:04:49
DNI fuera del contexto 00:04:51
por eso aquí 00:04:53
en mostrar datos 00:04:55
yo quería mostrar la propiedad 00:04:56
DNI de cliente tiende, que sé 00:05:00
que la tiene, la tiene y no podía 00:05:01
no puedo, me dice, uy no puedes 00:05:03
claro, no, no pasa 00:05:06
nada, porque si 00:05:07
que tenemos el método get heredado 00:05:09
también, copia y pega aquí 00:05:11
y el método get tiene el modificador 00:05:13
public, entonces 00:05:15
es decir, no tiene privado, con lo 00:05:17
cual claro que puedo usar get dni para 00:05:20
lo mismo, que 00:05:21
es para lo mismo, pues para acceder al 00:05:23
valor de la propiedad, vale 00:05:25
entonces 00:05:27
¿me lo ha cogido? 00:05:29
sí 00:05:32
vale, entonces 00:05:32
cuidado con el modificador 00:05:35
privado, simplemente 00:05:37
Sed conscientes de que al estar aquí privado, en tiempo de desarrollo, en tiempo de escritura de mi código, me encuentro con la restricción de que no puedo acceder desde aquí a una propiedad que tiene él, que es una estupidez, la tiene él, se llama DNI, pues no puedo acceder desde ahí. 00:05:39
Con lo cual tengo que acceder con el get 00:05:59
Que es una situación estúpida 00:06:01
A una propiedad que yo tengo 00:06:03
Que es DNI, cliente online 00:06:05
No puedo acceder desde los métodos, vaya tontería 00:06:07
Pues no puedo 00:06:09
Vale, pues como eso realmente es una tontería 00:06:10
No poder acceder desde tu propia clase 00:06:13
A una propiedad que tienes tú, DNI 00:06:15
Se ha inventado un cuarto 00:06:17
Bueno, tercero 00:06:19
Porque el cuarto que es package 00:06:21
No se escribe, es opcional 00:06:23
Se ha incorporado un cuarto 00:06:24
Modo de acceso 00:06:27
que es el que cuando hablamos de los modos de acceso 00:06:28
lo mencioné y dije que tiene que ver con la herencia 00:06:31
y ya lo veremos 00:06:32
ese, que es el protect, se ha incorporado 00:06:33
entonces para evitar esta tontería 00:06:36
se dice, a ver 00:06:38
yo quiero que DNI y nombre sean privadas 00:06:40
quiero que sean privadas 00:06:43
para seguir satisfaciendo 00:06:44
este convenio de programación 00:06:47
y seguir 00:06:49
prohibiendo el acceso a DNI 00:06:50
de tal forma que les obligo 00:06:52
a acceder a través del GET y del SET 00:06:54
vale, quiero que sean privadas 00:06:56
pero claro, si alguien hereda de mí 00:06:59
se encuentra con esta tontería 00:07:01
al heredar de mí tiene DNI dentro 00:07:03
también, tiene DNI dentro 00:07:05
pero no puede acceder a ella 00:07:07
pues entonces 00:07:08
hay otro modificador que es el 00:07:10
modificador protected 00:07:13
vale 00:07:14
que este modificador significa 00:07:16
solamente puede acceder 00:07:19
a la propiedad 00:07:21
la propia clase cliente, está claro 00:07:22
desde dentro de cliente y también desde las herederas, ¿vale? 00:07:25
La propiedad es accesible o visible, como lo queráis llamar. 00:07:31
Desde la propia clase, bueno, eso por supuesto, claro, como si fuera privada también. 00:07:52
Y también desde las clases herederas. 00:07:58
Y cuando digo clases herederas estoy diciendo subclases. 00:08:06
son sinónimos, subclase es la clase heredera 00:08:12
superclase es la clase 00:08:15
de la creed, vale pues con este 00:08:16
modificador me salto 00:08:18
esa tontería 00:08:20
y ahora ya cliente online 00:08:22
hereda de cliente, tiene DNI dentro 00:08:24
como propiedad aunque yo no la vea pero ya 00:08:26
la puede escribir 00:08:28
la puede escribir si la necesita y no tiene que 00:08:29
tirar del get y el set todo el rato 00:08:32
vale, no está aquí 00:08:34
escrita pero la tiene 00:08:40
y como además aquí está con 00:08:42
protected, puedo yo desde 00:08:44
aquí hacer referencia a ella. La tengo 00:08:46
visible. Está visible ya. 00:08:48
¿Vale? 00:08:51
Entonces, el modificador protected 00:08:53
pues se usa mucho. 00:08:55
¿Puedes poner como disdelay? 00:08:57
¿Puedes poner como que es suya? 00:08:59
Sí, sí, sí, claro. 00:09:01
Claro, claro, es suya. 00:09:03
¿Dónde estamos? 00:09:07
Es su propiedad. Es que hay un copia y pega ahí, 00:09:15
aunque no lo hayamos hecho nosotros. 00:09:18
¿Vale? 00:09:19
La puedo dejar puesta, lo que queráis. 00:09:25
No, normalmente no se pone. 00:09:26
Sí, vale. 00:09:28
Vale, pues entonces este modificador 00:09:30
ya lo incorporamos con un modificador más 00:09:32
que ya no hay más modificadores de acceso. 00:09:34
El private este, que es aquel miembro, 00:09:37
sea propiedad, sea método, 00:09:42
al que hace referencia, 00:09:45
solo es visible, solo se puede acceder 00:09:47
desde la misma clase. 00:09:50
Ese es el privado. 00:09:51
Vale. 00:09:52
Segundo nivel de acceso 00:09:53
La nada 00:09:55
El nivel de acceso la nada 00:09:57
Es el que se llama package 00:10:00
El nivel de acceso la nada 00:10:01
Significa que esta propiedad 00:10:03
O ese método 00:10:05
Que no tiene modificador de acceso 00:10:06
O que tiene el modificador de acceso por defecto 00:10:08
Como lo queráis ver 00:10:10
Es visible desde la misma clase 00:10:11
Y también desde todas las clases 00:10:14
Del mismo paquete 00:10:17
Del mismo paquete 00:10:18
Vale 00:10:19
el siguiente 00:10:21
modificador de acceso que hemos visto, este, ya sabemos 00:10:23
lo que significa, esta propiedad 00:10:26
o ese método 00:10:28
al que modifica 00:10:29
es accesible o visible 00:10:31
desde todas las clases 00:10:34
de todas partes 00:10:36
claro 00:10:37
sí, desde todas partes 00:10:39
sin claro y sin nada 00:10:44
recordad que luego 00:10:45
recordad que esa clase realmente 00:10:47
su nombre, no es solo su nombre, es su nombre más el paquete al que 00:10:50
pertenece, vale, entonces modelo.cliente.dni 00:10:54
se podrá poner en cualquier parte, porque 00:10:58
dni es público, luego modelo.cliente.dni se puede poner 00:11:02
en cualquier sitio, no hay ningún problema de visibilidad, vale 00:11:06
si tengo el public, y recordad que si me quiero ahorrar 00:11:09
todo el rato el poner modelo.cliente, pues pongo 00:11:14
import modelo.cliente 00:11:18
y luego ya abajo 00:11:19
pongo cliente sin más 00:11:21
bueno, esto es 00:11:23
todo lo que 00:11:26
vale 00:11:26
bueno, pues entonces 00:11:30
nuestra aplicación era esta 00:11:38
tenía un diseño de clases con estas entidades 00:11:40
luego tenía un pedido 00:11:42
que como todos los clientes 00:11:43
tienen un conjunto de pedidos 00:11:46
pues por eso esto lo habíamos puesto aquí 00:11:48
vale 00:11:50
pero si el tema de los pedidos funcionara de forma distinta 00:11:51
en cliente online o en cliente tienda 00:11:56
pues entonces a lo mejor la propiedad relativa a los pedidos 00:11:57
habría que poner aquí cada una la suya 00:12:03
pero como todos los clientes después de haber hecho el análisis 00:12:04
y el diseño todos en esta aplicación en concreto 00:12:08
hemos deducido a ver todos me da igual que sean tienda o cliente 00:12:11
todos se caracterizan por tener un array de pedidos 00:12:15
pues como todos se caracterizan por eso 00:12:17
pues lo podemos poner aquí 00:12:19
y luego 00:12:21
el otro día ya hicimos 00:12:25
una serie de funcionalidades 00:12:28
ya en un main 00:12:30
ya en una aplicación concreta 00:12:32
hicimos una serie de funcionalidades 00:12:33
que nos permitieron ver 00:12:34
la flexibilidad 00:12:36
que nos otorga 00:12:38
esta arquitectura de derecho 00:12:40
porque podríamos haber diseñado esta aplicación 00:12:42
de otra manera, podríamos haber dicho 00:12:47
hombre en lugar de hacer una super clase 00:12:48
con lo común y dos clases que hereden 00:12:51
Pues me hago dos clases y ya está, cliente tienda, cliente online, cliente tienda con todo lo suyo, cliente online con todo lo suyo y ya está, es otro diseño distinto, pero entonces no pasaba todo esto que nos hemos encontrado que pasa cuando hicimos esto, ¿vale? 00:12:53
Por ejemplo, vamos a revisar, antes de que hagáis las demás, la funcionalidad de mostrar datos clientes, que es donde vimos la potencia que nos da que la arquitectura sea adherencia en lugar de ser dos clases separadas, que no comparten una superclase. 00:13:11
Vale, pues aquí dijimos 00:13:33
Venga, vamos a hacer la funcionalidad de mostrar datos clientes 00:13:36
Nuestros clientes 00:13:38
Están todos 00:13:41
En un array de clientes 00:13:41
Que hemos ido rellenando con la funcionalidad 00:13:44
La primera cosa 00:13:46
Importantísima 00:13:49
Que nos ha permitido la herencia 00:13:51
Recordad que era 00:13:54
La primera, no lo olvidéis 00:13:55
Que en una referencia cliente 00:13:57
Es decir, una referencia 00:14:00
De la superclase 00:14:01
puedo meter yo ahora objetos cliente, new cliente 00:14:02
u objetos de cualquier superclase, esa es la primera ventaja 00:14:06
es decir, clientes de cero al ser 00:14:10
de tipo cliente puede tener un cliente tienda o un cliente online, me da igual 00:14:14
porque ambos se heredan de cliente, es decir 00:14:18
no tengo que hacer un array para los clientes 00:14:23
online y otro array para los clientes tienda 00:14:28
no tengo por qué hacerlo 00:14:32
puedo hacer un único array 00:14:33
y en ese array, en cada una de las posiciones 00:14:35
al ser de tipo cliente, caben 00:14:38
cliente tienda, cliente online, da igual porque son subclases 00:14:39
esa es la primera cosa 00:14:42
bueno, pues con la funcionalidad 1 00:14:43
insertamos clientes, etc 00:14:46
y ahora nos pusimos a hacer la 2 00:14:47
mostrar datos de cliente 00:14:49
bueno, pues la funcionalidad 2 00:14:52
dijimos, vale 00:14:54
pues para mostrar los datos 00:14:56
de todos los clientes 00:14:58
la funcionalidad era mostrar los datos de todos 00:14:59
pues vamos a hacer un for 00:15:01
que me recorra todos los clientes 00:15:03
bueno, pues como 00:15:06
este for queremos que recorra 00:15:07
todas las posiciones 00:15:10
el for each mucho mejor 00:15:12
porque es más cómodo de escribir 00:15:13
el for each lo único es eso 00:15:15
que nos fuerza a recorrer todas 00:15:18
y solo vale 00:15:19
si yo no cambio la posición 00:15:22
de estos objetos, por supuesto 00:15:24
porque esto es una copia 00:15:25
bueno, pues los voy recorriendo 00:15:26
y decíamos, vamos a ver 00:15:29
yo lo que quiero 00:15:31
es mostrar los datos de cada objeto 00:15:35
cliente, ¿vale? es lo que yo quiero 00:15:37
mostrar los datos 00:15:39
entonces hombre, podría meter aquí un system out 00:15:40
para cada cliente los datos, pero dijimos 00:15:43
bueno hombre, vamos a empezar a hacer las cosas ya con métodos 00:15:45
y modular, ¿vale? pues entonces 00:15:47
yo quiero 00:15:49
que haya un método mostrar clientes 00:15:51
que me muestre los datos del cliente 00:15:53
¿vale? 00:15:55
bueno, una vez que dijimos que 00:15:57
que bien nos vendría un método 00:15:59
mostrar clientes para mostrar los datos del cliente 00:16:01
y no tener que hacer el system out aquí en el main 00:16:04
dijimos vale 00:16:06
ese método donde lo pongo 00:16:08
lo puedo poner 00:16:09
en cliente pero es que cliente 00:16:12
si yo hago un mostrar clientes 00:16:14
solo puede mostrar DNI y nombre 00:16:15
pues se queda cojo 00:16:17
porque cliente online 00:16:20
tiene además un medio de pago 00:16:22
y un email y cliente tienda 00:16:24
tiene además 00:16:26
una dirección postal 00:16:27
con lo cual 00:16:30
el mostrar clientes de aquí 00:16:32
solo podría mostrar 00:16:34
DNI y nombre, luego si lo hago 00:16:36
aquí y lo heredo desde las 00:16:38
demás, se me queda cojo 00:16:40
luego ese no es el sitio de hacer el método 00:16:42
mostrar clientes, tenemos que hacer uno específico 00:16:44
aquí 00:16:46
que muestre 00:16:47
los datos del cliente 00:16:49
online, que lo muestra todo, medio de pago 00:16:52
email, etcétera 00:16:54
y uno específico aquí 00:16:56
que me estaba los datos 00:16:57
del cliente tienda 00:16:59
con su DNI, su nombre y su dirección postal 00:17:00
uno específico en cada clase 00:17:03
porque el heredado de la superclase 00:17:05
no nos vale 00:17:07
vale, bueno, pues entonces ahora ya 00:17:08
una vez hechos esos métodos, continuamos 00:17:11
con nuestro main 00:17:13
y decíamos, vale, ahora 00:17:13
cada método, ahora yo ya 00:17:16
me hago el bucle para mostrar 00:17:18
los clientes y 00:17:23
me encantaría hacer esto 00:17:25
cl. 00:17:26
Vale, entonces en cliente, como aquí no era el sitio de mostrar datos porque solamente puedo mostrar dos, pues aquí no lo hacía. Ahí no, sí, sí, sí, pero bueno, como estoy para los rezagados. Vale, entonces ahí no lo hacía porque ese no me vale para nada. El de cliente no me vale para nada porque se queda a medias. Solo muestra ADN y nombre, se queda a medias. Ese no me vale. 00:17:31
entonces para qué lo voy a poner 00:17:54
si luego 00:17:56
el cliente online 00:17:58
lo va a heredar mal 00:18:01
porque el cliente online tiene más datos 00:18:02
y el cliente tiene también, para qué lo voy a poner 00:18:04
no me interesa este método que luego lo hereden 00:18:06
entonces no hacíamos el método 00:18:08
y aquí ya hacíamos 00:18:10
uno específico 00:18:12
para cada clase, uno bueno 00:18:14
aquí el suyo y aquí el suyo 00:18:16
como son distintos, uno en cada clase 00:18:18
no hay tutía 00:18:20
vale, entonces ahora nos íbamos al main 00:18:21
y decía, pues venga, vamos a mostrarlos para cada cliente de mi array, 00:18:24
mostrar los datos. 00:18:32
Pero claro, el compilador me dice, uy, el compilador, 00:18:34
recordad que esto era lo más importante de la herencia, 00:18:38
el compilador mira reglas de sintaxis, reglas sintácticas, 00:18:42
no mira si esto tiene sentido o no. 00:18:46
Esto sentido tiene todo el del mundo, porque CL, 00:18:49
aunque está declarado como cliente, 00:18:52
CL es o cliente tienda o cliente online. 00:18:54
Eso ya lo sabemos, cuando se ha instanciado, se ha instanciado como cliente online o cliente tienda, lo tenemos claro. 00:18:57
Luego, esto sentido tiene, llamar a mostrar datos, pero el compilador solamente mira reglas sintácticas y dice, oye, CL está declarado como cliente, voy a ver si en cliente hay un mostrar datos, porque si no lo hay, no te dejo ejecutarlo, no te dejo escribirlo. 00:19:03
el compilador se va a la clase 00:19:20
a la cual está declarada cliente 00:19:24
y dice, uy en cliente 00:19:26
no hay ningún mostrar datos, lo siento 00:19:28
no te dejo escribir 00:19:30
mostrar datos, no te dejo 00:19:32
escribirlo 00:19:33
porque mis reglas sintácticas 00:19:34
dicen que si CL 00:19:38
está declarado como clase cliente 00:19:40
tú solamente puedes llamar a métodos que 00:19:42
estén en cliente 00:19:43
y en cliente no lo tienes 00:19:45
pues aquí nos hemos quedado atascados 00:19:46
¿Vale? Es en lo que nos quedamos el otro día 00:19:49
Y todo porque 00:19:51
El compilador sigue una regla sintáctica 00:19:52
Muy restrictiva 00:19:55
Pero claro, esto decíamos 00:19:56
Esto no tiene sentido, pero si en el 00:19:59
Objeto cliente 00:20:01
Que se ha creado con el 00:20:02
New como cliente tienda o cliente online 00:20:05
Sí que está el método 00:20:06
Pues vamos a 00:20:07
A callar al compilador dejándole 00:20:10
Tranquilo y diciéndole, vamos a ver 00:20:12
A ti lo que te pasa 00:20:14
Para dejarme ya en paz y dejar de poner 00:20:16
eso rojo, es que necesitas 00:20:18
que exista un método 00:20:21
mostrar datos en la clase 00:20:22
cliente, porque 00:20:24
yo estoy declarado como cliente, aunque 00:20:26
luego esté creado, instanciado con el 00:20:28
new como tienda online 00:20:30
es lo que necesitas 00:20:32
ver que hay un método mostrar datos ahí en la clase 00:20:34
cliente, pues yo te doy 00:20:36
un método mostrar datos, ala 00:20:38
este mismo, que no me 00:20:40
vale para nada y no me interesa 00:20:42
porque no muestra las propiedades del objeto 00:20:44
total 00:20:47
si, podríamos dejarlo vacío 00:20:48
sería el siguiente paso 00:20:52
pues yo te pongo ahí un método 00:20:54
como si pongo bla bla bla jejeje 00:20:58
como si te pongo ahí 00:21:00
pesado, voy a hacer este método porque eres 00:21:02
un pesado, compilador 00:21:04
como si pongo lo que me dé la gana 00:21:06
pero bueno, ya que nos ponemos a hacerlo 00:21:07
hemos puesto esto, porque oye, quien sabe 00:21:10
a lo mejor en esta aplicación pueden llegar a existir 00:21:11
objetos clientes sin más 00:21:14
porque esto es una clase más, cliente 00:21:16
pues a lo mejor yo instancio un objeto cliente 00:21:18
sin más que tiene DNI nombre 00:21:20
pues a lo mejor ese objeto cliente 00:21:22
quiere llamar a su mostrar datos 00:21:24
bueno, pues venga, me hago un método 00:21:25
mostrar datos 00:21:28
y ya el compilador se calla 00:21:29
y dice, uy que bien 00:21:32
el objeto CL 00:21:34
que está declarado como cliente 00:21:35
yo me voy a la clase a la que pertenece 00:21:38
y tiene un mostrar datos, ya se queda callado 00:21:40
vale 00:21:42
se queda callado 00:21:44
esto lo vamos a seguir dejándolo comentado 00:21:45
esto ya lo he escrito arriba 00:21:49
lo quito de aquí, se queda callado 00:21:52
y ahora es cuando me diríais 00:21:54
vosotros, si no fuera 00:21:56
porque ya lo sabéis, me diríais 00:21:58
ya claro, pero es que no queremos 00:22:00
llamar a mostrar datos de la clase cliente 00:22:02
queremos llamar 00:22:04
a mostrar datos de cliente 00:22:06
online cuando sea cliente online 00:22:08
y queremos llamar a mostrar 00:22:10
datos de cliente tienda cuando sea cliente 00:22:12
tienda, que son los buenos 00:22:14
claro, estupendo, pero es que eso ya lo hace 00:22:15
la máquina virtual por nosotros 00:22:18
entonces 00:22:20
importante que distingamos 00:22:21
tiempo de escritura de código, tiempo de desarrollo 00:22:24
cuando el desarrollador está haciendo su 00:22:27
aplicación en la cual tiene que 00:22:28
por supuesto dedicar mucho tiempo a su diseño 00:22:30
qué clases hace 00:22:33
qué entidades, qué relaciones 00:22:34
hace entre ellas, qué propiedades tiene cada una 00:22:36
si tiene una estructura de herencia o no 00:22:39
que tenga sentido 00:22:41
crear los métodos 00:22:41
y ahí en ese tiempo de desarrollo 00:22:44
es que tienes que cumplir las reglas 00:22:46
aunque Java te ponga mil y muchas 00:22:48
pues hay que cumplirlas todas 00:22:51
¿vale? porque si no el compilador 00:22:52
te dice no, esto no compila 00:22:54
no te hago un punto class 00:22:57
con lo cual no puedes ejecutar 00:22:59
ya hemos cumplido todas las reglas 00:23:00
el compilador ya se ha callado 00:23:03
y ya nuestra aplicación asumimos que está bien 00:23:04
saltamos al tiempo de ejecución 00:23:07
que es el tiempo en el cual yo ya 00:23:10
lanzo la aplicación para que se ejecute 00:23:13
para la cual tiene que haber 00:23:16
un main, obviamente 00:23:18
tiene que haber un main 00:23:18
porque el punto de arranque de cualquier aplicación 00:23:21
Java de escritorio, no web 00:23:23
ni nada de eso, es un main 00:23:25
vale, tiene que haber un main 00:23:28
bueno, pues ese main 00:23:29
arranca ya en tiempo de ejecución 00:23:32
la máquina virtual lo arranca y empiezan 00:23:34
a funcionar, a pasar cosas 00:23:36
¿y qué es lo que empieza a pasar? 00:23:37
pues que empiezan a instanciarse objetos 00:23:39
aquí cada vez que le demos a insertar 00:23:41
cliente pues se empezarán a 00:23:43
instanciar objetos, aquí un new 00:23:45
cliente tienda, cuando yo creo un cliente 00:23:47
tienda, cuando creo 00:23:49
un cliente online llamando a este método 00:23:51
pues se instanzaría un cliente online 00:23:53
eso es lo que empieza a pasar 00:23:55
en tiempo de ejecución, que empezamos a dar 00:23:57
opciones, se empiezan a hacer 00:23:59
los news, news, news, se empiezan a ejecutar, se empiezan 00:24:01
a aparecer objetos 00:24:03
en memoria RAM están ahí esos objetos 00:24:04
cada uno perfectamente identificado 00:24:07
si es cliente online, si es cliente tienda, si es cliente pepito 00:24:09
vale, pues ahora en tiempo de ejecución 00:24:12
le damos a la opción 2, ya en tiempo de ejecución 00:24:15
no desarrollando, ya hay un tío ahí dándole las opciones 00:24:18
y en tiempo de ejecución la máquina virtual se encuentra 00:24:20
con el problema de que para cada uno de los objetos 00:24:24
de la raíz real que ya existe, que está en memoria de la raíz real 00:24:27
que ya existe, tiene que demostrar datos 00:24:30
bueno, pues la máquina virtual, dijimos, a la máquina virtual 00:24:32
le da exactamente igual 00:24:36
como esté declarado este objeto 00:24:38
si está declarado como cliente 00:24:40
está declarado como Juanito y está declarado como Pepito 00:24:42
le da igual, eso solo le importó 00:24:44
al compilador que es el que nos 00:24:46
dictó las reglas 00:24:49
a la máquina virtual que ahora 00:24:49
tiene que ejecutar el método, que es la que tiene que hacer 00:24:52
ya el trabajo de ejecutar el método, a la máquina virtual 00:24:54
solo le interesa 00:24:57
ir a la memoria RAM a ver este objeto 00:24:58
como se creó, si se creó con 00:25:01
new cliente tienda, se creó con new client 00:25:03
es lo único que le importa, esto le da igual 00:25:04
vale, pues la máquina virtual dirá 00:25:07
a ver CL, me voy a la RAM 00:25:09
CL, tú que eres, eres un cliente online 00:25:11
vale, pues entonces 00:25:13
llamo al mostrar datos del cliente 00:25:15
online 00:25:18
que es el bueno 00:25:18
que no 00:25:20
que yo me voy a la RAM 00:25:23
y veo que el objeto CL 00:25:25
se ha creado en RAM 00:25:27
como cliente tienda 00:25:29
cuando el usuario dio a dos y lo creó 00:25:30
bueno, pues entonces llamo al mostrar 00:25:33
datos de cliente tienda 00:25:35
que es el bueno 00:25:37
el que tiene todas las propiedades 00:25:39
y entonces esto ya está 00:25:41
funciona perfectamente 00:25:43
bueno pues 00:25:44
esto era la segunda 00:25:46
potencia 00:25:50
fundamental de la herencia 00:25:51
la primera repito 00:25:53
poder guardar en una referencia 00:25:55
de una clase objetos 00:25:57
no solo de esa clase 00:25:59
sino de las herederas 00:26:01
eso facilita mucho la escritura del código 00:26:02
me permite arrays únicos para objetos de diferente tipo, etc. 00:26:05
Y la segunda, esto que acabamos de decir, 00:26:10
que era lo que se llamaba, lo que se llama polimorfismo. 00:26:14
La segunda es el polimorfismo, que es, 00:26:18
oye, mostrar datos, este de aquí no es un solo método, 00:26:21
son muchos, tiene muchas formas, 00:26:26
de ahí lo de polimorfismo, son muchos. 00:26:30
¿Cuáles son? Pues depende. 00:26:32
si CL está instanciado como cliente 00:26:34
online, mostrar datos 00:26:37
será el mostrar datos de cliente online 00:26:38
si CL está instanciado como cliente 00:26:40
tienda, mostrar datos 00:26:43
será el 00:26:44
la versión de cliente tienda 00:26:45
si CL está instanciado como cliente 00:26:48
que podría ser mostrar 00:26:51
datos, será 00:26:52
el mostrar datos de cliente 00:26:54
luego mostrar datos 00:26:56
tiene una única llamada, único nombre 00:26:58
y muchas versiones, tiene esta 00:27:01
versión, tiene esta 00:27:03
otra, tiene esta 00:27:05
tiene muchas 00:27:07
en toda la arquitectura de las clases, subclases 00:27:08
superclases, en cada una tiene su versión 00:27:11
tiene un montón de formas 00:27:13
en cada clase tiene una 00:27:14
la llamada es única 00:27:16
para los objetos de clase cliente 00:27:18
¿qué versión se llama? 00:27:21
depende de cómo esté instanciado 00:27:22
¿vale? 00:27:24
pues este es el polimorfismo 00:27:27
y el polimorfismo nos ha 00:27:28
simplificado la vida 00:27:31
porque yo me cojo 00:27:31
todos los clientes 00:27:33
me olvido de qué tipo son 00:27:34
me despreocupo 00:27:37
y llama a mostrar datos 00:27:39
y me despreocupo de todo 00:27:43
y sé que mostrar datos 00:27:44
estará llamando al que toca 00:27:46
a uno o a otro 00:27:47
yo no lo sé y me da igual 00:27:48
lo sabe la aplicación 00:27:53
la aplicación sabe a cuál tiene que llamar 00:27:54
que será al que corresponda 00:27:57
al objeto que está instanciado 00:28:00
aquí, entonces 00:28:01
tu tarea como desarrollador 00:28:03
no es decir todo lo que va a pasar en tiempo 00:28:05
de ejecución, porque eso depende de cada ejecución 00:28:07
tu tarea como 00:28:10
desarrollador es hacer un código 00:28:11
que haga 00:28:13
lo que te piden, y aquí lo que te piden 00:28:15
que es, meter un montón de clientes 00:28:17
del tipo que sea 00:28:20
que tú en tiempo de desarrollo no sabes que tipo es 00:28:21
en una ejecución puede que te metan todos de tienda 00:28:23
en otra puede que te metan todos de online 00:28:25
tu tarea es 00:28:27
garantizar que en cualquier circunstancia 00:28:29
esto va a funcionar bien 00:28:32
bueno, pues esto funciona bien con estas dos líneas 00:28:33
aquí cabe 00:28:35
cualquier tipo de objeto cliente 00:28:37
y subclase, cualquiera, en cada ejecución 00:28:39
irán unos, irán otros, da igual, ahí caben 00:28:41
todos, y además tú como 00:28:43
desarrollador solo con esta única 00:28:45
línea, sabes 00:28:47
que da igual los objetos que hay ahí, ya la máquina 00:28:49
virtual va a llamar a la versión buena 00:28:51
tú como desarrollador 00:28:53
ya has escrito lo que tenías que escribir 00:28:55
para que funcione para cualquier tipo 00:28:57
de objeto, y ya está 00:28:59
tú no puedes saber qué tipo 00:29:01
de objeto hay ahí, depende de la ejecución 00:29:03
¿vale? 00:29:05
entonces, esto era el polimorfismo 00:29:08
que nos permite escribir en 00:29:09
esta única línea 00:29:11
todo lo que si no tendríamos que 00:29:12
haber hecho de esta otra forma que está comentada 00:29:15
de aquí 00:29:17
¿vale? esta forma 00:29:18
que es la que hubiéramos tenido que usar si no hubiera 00:29:25
polimorfismo es 00:29:27
a ver, voy a distinguir CL 00:29:28
de qué tipo es 00:29:31
para eso teníamos este operador 00:29:32
que incorporábamos como nuevo 00:29:35
que nos permite distinguir un objeto 00:29:37
como se ha instanciado 00:29:39
no como se ha declarado 00:29:41
vale, que te has instanciado como cliente 00:29:42
tienda, te voy a convertir 00:29:45
en cliente tienda con un casting 00:29:47
casting que no me va a dar ningún problema 00:29:49
porque es que sé que es cliente tienda 00:29:51
luego puedo convertir algo en 00:29:53
una cosa que es sin transformarla 00:29:55
y ya está, y una vez que te he 00:29:58
convertido, ya llamo a tu método, 00:30:01
llamo a lo que sea. En este caso se vería mejor 00:30:03
si llamamos a mostrar 00:30:05
datos. Vale, 00:30:07
llamo ya a la versión de mostrar datos 00:30:09
de cliente tienda, porque 00:30:11
te he hecho el casting, porque he verificado previamente 00:30:13
que eres tipo tienda. ¿Que no? 00:30:15
¿Que eres cliente online? Pues te hago el casting 00:30:17
a cliente online 00:30:19
y llamo a tu versión 00:30:21
de mostrar datos de cliente online. 00:30:23
Bueno, pues todo este 00:30:26
rollo no es necesario 00:30:27
porque esto ya lo hace la máquina virtual 00:30:29
por nosotros 00:30:31
la máquina virtual ya dice 00:30:32
oye tú que eres cliente tienda 00:30:34
pues te hago el casting y llamo a tu versión 00:30:36
tú que eres cliente online 00:30:38
pues te hago el casting y llamo a tu versión 00:30:40
ya lo hace todo ahí 00:30:42
en esa única línea 00:30:44
luego nos ahorramos todo esto 00:30:45
vale 00:30:48
pues claro, claro, claro 00:30:53
esto es más o menos 00:30:56
lo que de herencia 00:31:01
tenemos que tener claro hasta ahora 00:31:03
vale 00:31:05
entonces ya que estábamos con esta aplicación 00:31:06
pues ya la usamos para dejar 00:31:08
alguna otra funcionalidad 00:31:10
para hacer, como la 3, la 4 y la 5 00:31:12
agregar pedido a un cliente 00:31:14
decidiendo donde podemos poner ese método 00:31:17
mostrar al cliente que más 00:31:18
haga hasta ahí de qué tipo es 00:31:19
y fijar descuento clientes online 00:31:22
a ver, la funcionalidad 5 00:31:24
la podemos hacer ahora mismo 00:31:27
antes de que hagáis vosotros 00:31:28
si es que no la habéis hecho, la 3 y la 4 00:31:30
que la hagáis ahora en un ratito 00:31:32
dijimos esta aplicación 00:31:33
para ampliarla un pelín más 00:31:36
o algo así 00:31:39
y para distinguir clientes online de tienda 00:31:39
el que nos pidió 00:31:43
esta aplicación nos dijo 00:31:49
a ver, cuidado que te incorporo 00:31:50
una característica más 00:31:52
así que amplíame la aplicación 00:31:54
te incorporo 00:31:56
que a los clientes online les voy a hacer un descuento 00:31:57
entonces nosotros como desarrollo decimos 00:32:00
a ver, esta incorporación, ¿qué hago? 00:32:01
¿en qué se traduce? ¿qué es un descuento? 00:32:03
un valor, una propiedad 00:32:05
vale, ¿dónde la coloco? 00:32:07
es relacionada con clientes online 00:32:09
porque es el descuento para clientes online 00:32:11
vale, pues la coloco aquí 00:32:13
¿es diferente para cada cliente? 00:32:14
podría serlo si el 00:32:17
que me pide la aplicación 00:32:19
me lo dijera, cada cliente va a tener un descuento distinto 00:32:21
que tú le metes en función de su nombre 00:32:23
o lo que sea 00:32:25
yo qué sé, porque iba a decir en función de su género 00:32:26
pero me parecía un poco 00:32:29
pues de su nombre 00:32:30
pero no, el mismo para todos 00:32:32
bueno, pues me hice el mismo para todos 00:32:35
pues ya me la he caracterizado del todo 00:32:37
la pongo como estática dentro de cliente online 00:32:39
y ya está 00:32:42
luego la funcionalidad de fijar descuento 00:32:42
clientes online, la 5, es que es una línea 00:32:46
que 00:32:48
la podemos poner aquí rápidamente 00:32:49
antes de que hagáis las demás 00:32:53
que le diríamos, venga pues dinos el descuento 00:32:54
descuento que quieres 00:32:57
y aquí ya hacíamos 00:33:04
cliente 00:33:06
online 00:33:09
line punto descuento igual a lo que me hayan pedido entero y me falta el break porque si no 00:33:10
me va a decir adiós venga la 5 ya está es fijar el descuento como es una variable estática la 00:33:22
llamó desde la clase las variables estática también por convenio pues como no son propiedades 00:33:34
de los objetos no se incorporan los get y set los get y set son para leer y fijar propiedades 00:33:40
los objetos, estas tienen otra 00:33:45
interpretación, pues entonces no se 00:33:47
incorporan los getises, se ponen como public 00:33:49
y se llaman directamente para la clase 00:33:51
y todo más bonito y más fácil, de nuevo 00:33:53
un convenio, claro 00:33:55
vale, pues la 5 ya estaría 00:33:56
pues a ver la 00:33:58
3 y la 4 00:34:00
¿la habéis hecho? 00:34:03
no, pues hacedlas 00:34:05
venga, ya mímico 00:34:07
un minuto y medio 00:34:09
no, venga, dos y medio, no, un poquito más 00:34:10
porque 00:34:13
Gracias. 00:34:14
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:
23
Fecha:
16 de enero de 2025 - 17:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 16″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
152.55 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid