Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 2-02-24 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 2 de febrero de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, añadir cliente, un poco rollo escribirlo, pero bueno, vamos a escribirlo rápidamente 00:00:00
Vamos a decirle que elija 00:00:06
A ver, primero le decimos de tienda o online 00:00:09
Vale, y ahora leemos el tipo así 00:00:15
Vale, de tienda o online 00:00:23
Y ahora ya pedimos los datos, NIF nombre y dirección o email 00:00:30
Eso ya sí que va a valer 00:00:34
NIF 00:00:35
Y ahora leemos el NIF 00:00:39
NIF de esto 00:00:46
NIF de esto 00:00:52
Leer cadena, lo mismo para el nombre 00:00:53
Lo mismo para el nombre 00:00:57
Y ahora sí que se pide dirección o email en función de si es de tienda o... 00:01:08
Y ya está 00:01:18
Pues si tipo es igual a 1 00:01:19
Pues entonces habrá que decirle, como es de tienda, que introduzca dirección 00:01:23
Vale, y en ese caso, pues ahora ya leemos la dirección 00:01:27
Estrindir igual a 00:01:39
Cadena 00:01:45
Vale, y aprovechamos ya aquí... 00:01:51
Vale, y aprovechamos ya aquí... 00:01:51
Vale, y aprovechamos ya aquí... 00:01:52
Vale, y aprovechamos ya aquí... 00:01:52
Vale, y aprovechamos ya aquí... 00:01:52
Para crear un objeto cliente tienda, porque estamos en tipo 1 00:01:53
Pues entonces nos hacemos un... 00:01:58
Cliente tienda 00:02:01
Cliente tienda C 00:02:03
¿Perdón? 00:02:07
Sí, esto es primero para que me digan qué tipo de cliente va a crear 00:02:14
Ahora ya 00:02:18
Nombre y NIF, ¿cómo es de ambos? 00:02:19
Nombre y NIF, ¿cómo es de ambos? 00:02:22
Los leo para ambos 00:02:23
Y ahora ya, si es de tienda, le pido dirección 00:02:24
Y creo un cliente tienda 00:02:26
Como en cliente tienda no le he hecho constructores 00:02:30
A propósito, porque lo de los constructores con herencia es un pelinín más complicado 00:02:34
Lo creo sin parámetros 00:02:38
Y ahora le voy a fijar los valores 00:02:40
Vale, con el set y el net 00:02:42
Como veis, C es objeto cliente tienda 00:02:44
¿Verdad? Es cliente tienda 00:02:48
Y en cliente tienda, le pido dirección 00:02:50
En cliente tienda 00:02:52
Me he lanzado 00:02:53
Me pasa a menudo 00:02:56
En cliente tienda 00:02:57
Como veis 00:03:00
No hay un método set NIF 00:03:01
Cliente tienda, fijaos lo que tiene 00:03:04
Esto, no tiene más que esto 00:03:06
Pero no pasa nada porque lo ha heredado de cliente 00:03:08
Entonces como lo ha heredado de cliente 00:03:13
Yo lo estoy pudiendo usar sin ningún problema 00:03:16
¿No? 00:03:18
C es objeto cliente tienda 00:03:20
Un objeto cliente tienda 00:03:21
No tiene un método set NIF 00:03:23
No lo tiene 00:03:25
Pero lo tiene heredado, aunque yo no lo vea físicamente 00:03:26
Aunque yo no lo vea hasta ahí 00:03:29
Entonces 00:03:30
Ahora 00:03:34
Voy a hacer lo mismo 00:03:37
Voy a fijarle el nombre 00:03:38
Y voy a fijarle la dirección 00:03:40
¿Vale? 00:03:45
Entonces, recopilamos 00:03:51
Si el tipo de cliente que vas a meter es tienda 00:03:54
Pido la dirección 00:03:57
Que es el dato que me falta 00:03:58
Porque el NIF y el nombre los tengo arriba 00:04:00
Pido la dirección 00:04:01
Y construyo un objeto de cliente tienda 00:04:03
Con esos tres valores 00:04:06
¿Vale? Los construyo 00:04:07
Ya tengo mi objeto cliente tienda con esos tres 00:04:09
¿Vale? Y de nuevo, repito 00:04:11
Fijaos que estos métodos que estoy llamando 00:04:14
El set NIF y el set nombre 00:04:16
No están escritos específicamente 00:04:18
En la clase cliente tienda 00:04:20
Pero es que están en cliente 00:04:21
¿Vale? 00:04:24
Y ahora con ese 00:04:31
¿Vale? 00:04:32
Y ahora ese cliente que acabo de crear 00:04:37
¿Vale? 00:04:40
Lo añado a la RAI 00:04:44
¿Vale? 00:04:46
Lo añado a la RAI 00:04:51
¿Vale? 00:04:53
Añadir a la RAI es lo de siempre 00:04:55
Añadir a la RAI es 00:04:57
Me creo un RAI 00:04:58
Auxiliar 00:05:01
De clientes 00:05:02
De una posición mayor 00:05:05
Que el que me han dado 00:05:15
Clientes.length 00:05:18
Más uno 00:05:21
Copio uno en otro 00:05:23
Copio uno en otro 00:05:29
Una vez que he terminado de copiar 00:05:41
La posición adicional, la relleno 00:05:49
Y ahora voy a copiar 00:05:51
Que es esta 00:05:51
La relleno con el nuevo 00:05:53
Y sobre escribo uno en el otro 00:05:57
Clientes igual a aux 00:06:00
Vale, obviamente hacer todo esto 00:06:01
En el menú del switch case 00:06:09
Era un rollo 00:06:10
Mejor en un método auxiliar 00:06:11
¿Vale? 00:06:12
Me he hecho un nuevo cliente 00:06:15
Con sus tres datos 00:06:16
Aquí ya me he aprovechado de la herencia 00:06:17
Por primera vez 00:06:19
Y ahora voy a copiar 00:06:20
Y ahora voy a copiar 00:06:21
Aquí me he aprovechado de la herencia 00:06:21
Por primera vez 00:06:25
Por estos sets que son heredados 00:06:25
De clientes 00:06:27
No están aquí 00:06:28
Y ahora ya lo he metido 00:06:29
En una posición adicional 00:06:31
Del RAI que me han pasado 00:06:32
Este es el RAI que me han pasado 00:06:33
Pues me hago uno adicional 00:06:35
Lo de siempre 00:06:36
Le pongo el nuevo 00:06:37
Y sobre escribo 00:06:38
Lo de siempre 00:06:39
Vale 00:06:41
Entonces si tipo no es igual a uno 00:06:42
Sino que es igual a dos 00:06:44
Voy a asumir 00:06:46
Para que no sea el código tan largo 00:06:48
No voy a verificarlo todo 00:06:49
Asumo que el tipo es igual a uno 00:06:51
O ha puesto uno 00:06:51
O ha puesto dos 00:06:53
Ya está 00:06:53
Porque es que si no me vuelvo 00:06:54
Si no 00:06:55
Pues no han metido el número correcto 00:06:55
Porque es que ya se hace enorme 00:06:57
Entonces lo metemos en un ELSE 00:06:59
Y ya está 00:07:00
El ELSE asumimos que es el dos 00:07:01
Que lo ha hecho bien 00:07:03
Porque si no 00:07:04
Y en el dos sería lo mismo 00:07:05
Pero cambiando dirección por email 00:07:08
¿Verdad? 00:07:11
Cambiando dirección 00:07:16
Por email 00:07:17
Vale 00:07:21
Y aquí cambiando cliente tienda 00:07:24
Por cliente online 00:07:30
Y aquí cambiando set dirección 00:07:31
Por set email 00:07:44
Vale 00:07:46
Aquí sería lo mismo 00:07:49
Pido el email 00:07:50
Me hago ahora un cliente online 00:07:51
Al que le fijo los tres parámetros 00:07:54
Hombre, esto para que quede más bonito 00:07:56
En lugar de dirlo 00:07:58
Voy a llamar email 00:07:58
Lo voy a llamar email 00:07:59
Y lo mismo 00:08:10
Vale, entonces si recopilamos 00:08:11
Lo que hemos hecho en este método 00:08:21
Es simplemente eso 00:08:23
Pedir el tipo de cliente 00:08:24
Pedir los datos comunes 00:08:27
Y luego ya 00:08:28
En función del tipo de cliente 00:08:30
O pedir dirección 00:08:32
Y construir el objeto cliente tienda 00:08:33
O pedir email 00:08:37
Y construir el objeto cliente online 00:08:38
¿Vale? 00:08:39
Pero hombre, ya que estamos 00:08:44
Jolín 00:08:45
Si esto 00:08:48
Este código 00:08:49
De aquí hasta aquí 00:08:51
Es igualito arriba y abajo 00:08:52
Es igualito 00:08:54
No es igualito arriba y abajo 00:08:55
Vamos a sacarlo fuera de elif 00:08:58
Else, ¿verdad? 00:09:00
¿Perdona? 00:09:13
En cliente tenemos 00:09:15
Nif y nombre 00:09:16
Sí 00:09:18
¿Sí? 00:09:20
Sí 00:09:21
Es que nosotros los hemos quitado 00:09:22
Claro 00:09:25
Vale, a ver 00:09:26
Repito 00:09:27
Entonces 00:09:28
No os perdáis 00:09:31
Porque todo esto es 00:09:32
Entonces uno se da cuenta y dice 00:09:34
Jolines 00:09:36
De aquí hasta aquí 00:09:37
Es que es igualito 00:09:39
Me hago uno añadido 00:09:41
Cofio y pego 00:09:43
Y ahora pongo 00:09:44
El nuevo aquí 00:09:45
Es que es el mismo 00:09:46
Este código 00:09:47
Y el código de abajo 00:09:48
Son ideas 00:09:49
Idénticos 00:09:51
Clavados 00:09:51
Línea por línea 00:09:51
¿No? 00:09:52
Entonces uno diría 00:09:53
Si hago eso 00:09:54
Tanto en elif como en elelse 00:09:54
Estoy haciendo lo mismo 00:09:56
Vaya por elif 00:09:57
Vaya por elif 00:09:58
Estoy haciendo lo mismo 00:09:59
Hombre 00:09:59
Pues póntelo luego al final 00:09:59
Y ya está 00:10:01
¿No? 00:10:01
Podría pensar uno 00:10:02
¿Vale? 00:10:03
Pues este que es el mismo código 00:10:05
Igualito 00:10:07
Idéntico 00:10:07
Igualito 00:10:08
Arriba y abajo 00:10:08
Igualito 00:10:09
Vamos a quitarlo de ahí 00:10:10
Y vamos a quitarlo de aquí 00:10:12
Porque es igualito 00:10:15
Igualito 00:10:17
Y lo voy a poner aquí al final 00:10:17
¿Verdad? 00:10:20
No tendría más sentido 00:10:24
Si ese código es igualito 00:10:25
A ver 00:10:27
No te pongas nervioso 00:10:29
Retrotraemos 00:10:30
Vamos a ver 00:10:37
Tú tienes 00:10:38
Imagínate que tú tienes un 00:10:38
If no sé qué 00:10:39
System printout 00:10:41
Hola 00:10:42
Else 00:10:42
System printout 00:10:43
Hola 00:10:44
Pues hombre 00:10:44
Si hago lo mismo 00:10:45
Vaya por elif 00:10:47
Por elelse 00:10:47
Pues pongo el system printout 00:10:48
Hola 00:10:49
Fuera 00:10:49
Ya está 00:10:50
Es lo que quiero decir 00:10:50
Simplemente 00:10:51
Solo eso 00:10:52
¿No? 00:10:52
Si yo 00:10:53
Esas líneas 00:10:54
Las hago igual 00:10:55
Al final del if 00:10:56
Que al final del else 00:10:57
Que son iguales 00:10:58
Las saco 00:10:58
A eso vamos 00:10:59
¿Vale? 00:11:03
Entonces 00:11:03
A lo que vamos 00:11:04
Yo aquí tengo 00:11:05
Un if 00:11:06
Que 00:11:07
Me hace una cosa 00:11:08
Y en el else 00:11:10
Me hace lo mismo clavado 00:11:11
Pues lo saco fuera 00:11:12
Porque 00:11:14
Me refiero 00:11:15
Que esa cosa 00:11:16
La va a hacer igual 00:11:16
Vaya por if 00:11:17
Que por elelse 00:11:18
Pues la saco fuera 00:11:18
¿Verdad? 00:11:19
Así funciona 00:11:20
El if y el else 00:11:20
¿No? 00:11:21
Esto es lo mismo que decir 00:11:22
Por si alguien 00:11:24
Imaginaos que tenemos 00:11:25
Aquí un 00:11:26
Vamos a hacer un método cualquiera 00:11:28
¿No? 00:11:31
Imaginaos que tenemos aquí 00:11:33
Pues eso 00:11:34
Un if condición cualquiera 00:11:35
Uno igual a dos 00:11:38
Que no me ponga error de compilación 00:11:41
Cualquier condición idiota 00:11:43
Si se cumple esta condición 00:11:44
Pues entonces 00:11:47
Me haces 00:11:48
Int n 00:11:50
Igual a uno 00:11:52
Y luego además 00:11:54
Me saludas 00:11:56
Ala 00:11:57
Y si no 00:11:58
Pues en ese caso 00:11:59
Me haces 00:12:02
Int m 00:12:03
Igual a dos 00:12:04
Y además 00:12:05
Me saludas 00:12:07
Esta es nuestra situación 00:12:09
¿No? 00:12:12
Esta es nuestra situación 00:12:13
Es la misma situación de arriba 00:12:15
Tengo un if y un else 00:12:16
Y la parte del final 00:12:18
Es idéntica en ambas partes 00:12:20
Es la misma situación de arriba 00:12:22
Lo mismo 00:12:25
Tengo un if y un else 00:12:25
Y esto es igual en ambos 00:12:27
Entonces hombre 00:12:28
Este código 00:12:30
Este código es exactamente igual 00:12:31
Que si yo quito estas dos cosas 00:12:33
Y las pongo al final 00:12:35
Hago lo mismo 00:12:36
¿No? 00:12:37
Entonces digo 00:12:41
Hombre 00:12:41
¿Para qué lo haces? 00:12:42
Si se cumple la condición 00:12:43
Haz esto de aquí 00:12:44
Más esto 00:12:45
Y si se cumple 00:12:46
Haz esto de aquí 00:12:47
Más esto 00:12:48
O sea 00:12:48
Esto lo haces igual 00:12:49
Vaya por donde vayas 00:12:50
Pues hombre 00:12:51
Ponlo fuera 00:12:51
¿Vale? 00:12:52
Es lo que 00:12:53
Es decir 00:12:53
Este código 00:12:54
Y este otro 00:12:55
Y este otro 00:12:58
Son exactamente igual 00:13:02
¿Verdad? 00:13:05
Entonces pues 00:13:06
¿Para qué? 00:13:06
Meter esto en las dos ramas 00:13:07
Lo pones fuera 00:13:09
Y el efecto es el mismo 00:13:10
El efecto es que se va a hacer igual 00:13:12
Vaya por el if que por el else 00:13:14
¿Vale? 00:13:16
¿Vale? 00:13:17
Es la situación que se nos está dando 00:13:17
En el for de arriba 00:13:19
¿Vale? 00:13:20
En el for de arriba 00:13:20
Este código 00:13:21
Era idéntico clavado 00:13:22
Idéntico clavado 00:13:24
Aquí al final 00:13:25
Y aquí al final 00:13:27
Era idéntico clavado 00:13:28
Entonces si era idéntico clavado 00:13:29
Sácalo fuera 00:13:30
¿Vale? 00:13:32
Hasta ahí tiene sentido 00:13:33
¿No? 00:13:34
¿Sí? 00:13:36
Claro 00:13:37
Pero ahora 00:13:38
Lo sacamos fuera 00:13:39
Y esta c 00:13:41
Se me pone roja 00:13:43
¿Por qué esta c se me pone roja? 00:13:44
Esa es la más importante de entender 00:13:49
Claro 00:13:51
Porque esta c 00:13:54
Es la variable cliente 00:13:55
Que yo la he declarado 00:13:57
Aquí 00:14:00
En la parte del if 00:14:01
O aquí en la parte del else 00:14:02
La tengo declarada aquí 00:14:05
Y recordad que una variable 00:14:06
Solo es visible 00:14:07
En el bloque 00:14:09
En el que está declarada 00:14:11
Y en los bloques que 00:14:13
Hay adentro de ese 00:14:16
Si es que hay alguno 00:14:17
Con lo cual 00:14:18
La variable c 00:14:19
Solo es accesible 00:14:20
Desde este bloque 00:14:21
Y este bloque acabó 00:14:22
Ese bloque acabó 00:14:23
Con lo cual 00:14:25
Desde aquí fuera imposible 00:14:26
Acceder a c 00:14:28
Aquí lo mismo 00:14:28
Esta variable c 00:14:30
Solo es visible 00:14:31
Desde este bloque 00:14:32
Dentro de él 00:14:33
Y este bloque acabó 00:14:35
Desde el momento 00:14:36
En que este bloque acabó 00:14:37
Todo lo que está declarado aquí 00:14:38
Email c 00:14:40
Aquí no existe 00:14:41
Con lo cual 00:14:42
No puedo poner aquí el c 00:14:44
Porque el c está declarado aquí 00:14:45
Y está declarado aquí 00:14:46
¿Cómo lo arreglo? 00:14:49
¿Vuelvo a meterlo adentro? 00:14:50
Pues vaya 00:14:51
No, ¿cómo lo podemos arreglar? 00:14:51
Jolín, qué perra tenéis con los métodos 00:14:56
Si el problema es 00:14:58
Que al declararla dentro del bloque 00:15:00
Solo es visible dentro del bloque 00:15:02
Y yo quiero que sea visible fuera 00:15:03
Pues la declaramos fuera 00:15:04
La declaramos fuera 00:15:06
Entonces esto 00:15:08
Esto es el trabajo 00:15:09
Todo el rato 00:15:10
Todas estas cuestiones 00:15:11
Que van surgiendo 00:15:12
Que vamos resolviendo 00:15:13
Este es el trabajo 00:15:13
Claro, mi problema es 00:15:15
Anda 00:15:17
Pues oye 00:15:18
Las vamos a declarar 00:15:19
Fuera 00:15:21
¿Vale? 00:15:21
Las vamos a declarar 00:15:23
Fuera 00:15:24
¿Vale? 00:15:24
Vale 00:15:39
Pero claro 00:15:40
Al sacarla fuera 00:15:46
¿Cuál es el problema que nos aparece? 00:15:49
Que aquí está declarada 00:15:51
Como cliente tienda 00:15:55
Y aquí está declarada 00:15:56
Como cliente online 00:15:58
Conclusión 00:15:59
Aquí como la declaramos 00:16:02
Como cliente tienda 00:16:07
O como cliente online 00:16:08
A ver, la puedo declarar como ambas 00:16:10
Efectivamente 00:16:16
O sea, dos 00:16:17
¿A qué te refieres? 00:16:17
Sí 00:16:18
Claro 00:16:18
La tengo que declarar como dos 00:16:19
Lo que pasa es que entonces 00:16:21
Aquí efectivamente 00:16:22
Esto lo tengo que destengar 00:16:23
Con un if 00:16:24
¿Vale? 00:16:25
Entonces aquí efectivamente 00:16:26
Hasta que no aprendamos 00:16:28
Un poquito más 00:16:29
Aquí el problema es que 00:16:30
Oye 00:16:32
¿Qué es? 00:16:33
¿Cliente tienda o cliente online? 00:16:35
Depende 00:16:37
Depende de donde esté 00:16:37
Depende de donde esté 00:16:39
Entonces 00:16:40
Vamos a declarar efectivamente 00:16:42
Un cliente tienda 00:16:45
Y vamos a declarar 00:16:46
Un cliente online 00:16:48
¿Vale? 00:16:51
Cliente tienda o cliente online 00:16:58
Y ahora 00:17:00
Este es cliente tienda 00:17:00
Este es cliente tienda 00:17:04
Esta de aquí 00:17:09
Y este es cliente online 00:17:13
Que ya le quito la declaración 00:17:16
Este es cliente online 00:17:17
Este es cliente online 00:17:18
¿Vale? 00:17:19
Entonces tengo 00:17:23
Un cliente tienda y un cliente online 00:17:24
¿Qué me han dicho cliente tienda? 00:17:26
Construyo el cliente tienda 00:17:28
Ya está, construido 00:17:30
Construido 00:17:31
¿Qué me han dicho el cliente online? 00:17:33
Construyo el cliente online 00:17:35
Ya está, construido 00:17:37
¿Vale? 00:17:38
Entonces o construyo el tienda 00:17:39
O construyo el online 00:17:40
Uno de los dos 00:17:41
¿Vale? 00:17:42
Y ahora ya 00:17:43
Ahora ya 00:17:44
Y solo una vez 00:17:45
Porque me da igual ir por el if 00:17:46
Por el elif 00:17:47
Que esto lo voy a hacer 00:17:48
En ambos casos 00:17:48
Y ahora ya 00:17:49
Hago el array 00:17:50
Lo amplio 00:17:51
¿Y qué meto en la posición adicional? 00:17:52
CO o CT 00:17:54
Pues depende 00:17:55
Depende de si el tipo es uno 00:17:56
O es otro 00:17:57
¿Vale? 00:17:58
Entonces ¿Qué metemos aquí? 00:17:59
Pues aquí depende 00:18:00
Aquí simplemente hacemos 00:18:01
Si tipo es igual a uno 00:18:04
Entonces meto cliente tienda 00:18:06
Y si no 00:18:11
Meto cliente online 00:18:12
Y listo 00:18:14
¿Vale? 00:18:15
Ahora el rojo 00:18:18
Ahora os pregunto por qué sale 00:18:22
Pero primero vamos a entender 00:18:23
Lo que hemos hecho 00:18:23
¿Vale? 00:18:24
Bueno, más o menos 00:18:33
Entonces ahora la estructura 00:18:34
Nos ha quedado 00:18:36
Yo tengo mis dos posibles objetos 00:18:36
El de tienda online 00:18:39
Si el cliente de selección o tienda 00:18:40
Construyo el de tienda 00:18:43
Pero si el cliente seleccionó online 00:18:44
Construyo el de online 00:18:47
¿Vale? 00:18:48
Construyo el de online 00:18:48
Depende el que haya seleccionado 00:18:50
Lo construyo 00:18:51
Y ahora ya 00:18:53
Me da igual cual he construido 00:18:54
Ya lo que me falta 00:18:55
En ambas ramas 00:18:56
Lo que me falta ya es esto 00:18:57
Que es meterlo en el array 00:18:58
¿Vale? 00:18:59
Pues para meter el array 00:19:01
Lo de siempre 00:19:02
Lo único es que 00:19:03
¿Cuál meto en la adicional? 00:19:04
Este o este 00:19:06
No lo sé 00:19:07
Depende de la condición 00:19:07
Este o este 00:19:08
No lo sé 00:19:09
¿Vale? 00:19:10
Pero esa sentencia está bien 00:19:11
Si el tipo era uno 00:19:12
Tendré que meter el CT 00:19:15
Que es el que habré construido en el if 00:19:16
Y si el tipo es dos 00:19:17
Tendré que meter el CO 00:19:18
Que es el que construyo en el else 00:19:19
¿Vale? 00:19:21
Tiene sentido 00:19:22
Y el método estaría muy bien 00:19:23
Y ya he hecho añadir cliente 00:19:24
En el array que me han pasado 00:19:26
Como parámetro, etc. 00:19:27
Y ahora 00:19:29
Antes de poner la manita 00:19:30
Yo os preguntaría 00:19:33
¿Por qué tampoco le gusta el compilador? 00:19:36
Que es tan pesidero 00:19:42
¿Por qué creéis? 00:19:43
Claro, nosotros sabemos 00:19:48
Porque nosotros conocemos 00:19:50
El funcionamiento de nuestro programa 00:19:51
Que si tipo es igual a uno 00:19:53
Sabemos 00:19:55
Que habrá entrado aquí 00:19:56
Habrá hecho el CT 00:19:58
Con lo cual CT tendrá algo 00:19:59
Y también sabemos 00:20:01
Que si tipo es igual a dos 00:20:03
Habrá entrado aquí 00:20:04
Y el CO tendrá algo 00:20:05
Pero el compilador no mira 00:20:06
Contenidos de variables 00:20:08
El compilador mira 00:20:09
Las combinaciones que hay 00:20:10
De if y de while 00:20:12
Y él dice 00:20:12
A ver 00:20:13
Solo va a tener algo 00:20:15
Si has entrado en el if 00:20:17
¿Yo cómo sé que has entrado en el if? 00:20:18
Yo no me pongo a mirar 00:20:20
En condiciones on true o false 00:20:22
Eso ya dependerá 00:20:23
De la ejecución concreta 00:20:24
Yo solo sé 00:20:25
Que la existencia de CT 00:20:27
Es condicional 00:20:28
No puedes 00:20:31
No tengo la garantía 00:20:32
De que CT siempre tenga un valor 00:20:33
Y ahora estás tratando 00:20:35
De usarla en una asignación 00:20:37
Y eso no le gusta 00:20:38
El compilador 00:20:40
Cuando usamos una variable 00:20:42
Para asignarla a algo 00:20:43
Dice 00:20:44
Oye 00:20:45
Esto está en un if 00:20:45
¿Cómo sé yo? 00:20:46
Que has entrado en ese if 00:20:48
Y que esa variable tiene algo 00:20:50
¿Cómo lo puedo saber? 00:20:51
Porque no mira condiciones 00:20:53
Porque dependen de la ejecución 00:20:54
¿Cómo lo puedo saber? 00:20:56
Entonces te dice 00:20:58
Para ahorrarnos problemas 00:20:58
No te dejo 00:21:00
Que en una asignación 00:21:02
Uses una variable 00:21:03
Que podría no tener nada 00:21:04
Podría no tenerlo 00:21:06
Si tú no has entrado en el if 00:21:07
Podría 00:21:08
Bueno 00:21:09
Pues se soluciona muy fácil 00:21:10
Tranquilo 00:21:11
No pasa nada 00:21:12
Yo cuando declaro 00:21:13
Te lo inicializo un valor 00:21:14
A cualquiera 00:21:15
Me da lo mismo 00:21:16
Porque es que luego yo sé 00:21:16
Que vas a entrar en el if 00:21:17
Y se va a dar un valor 00:21:18
Etcétera 00:21:20
Vale 00:21:21
Pues cuál es el valor 00:21:22
Que usamos para inicializar 00:21:23
A lo que sea 00:21:24
Un objeto 00:21:25
El null 00:21:26
Pues ya está 00:21:27
Como si ponéis 00:21:28
Un new cliente 00:21:32
Tienda vacío 00:21:33
Pero lo más bonito 00:21:34
Y lo normal 00:21:35
Es inicializarlo a null 00:21:35
¿Vale? 00:21:36
Pues entonces 00:21:48
Nuestro método 00:21:51
En principio 00:21:52
Ya está completo 00:21:53
Y menos mal 00:21:54
Que hemos hecho un método aparte 00:21:56
Porque hacer esto 00:21:57
En el switch case 00:21:58
¿Vale? 00:21:59
Entonces 00:22:00
Haz cliente 00:22:01
Le pasamos la cajita 00:22:02
Para meter los clientes 00:22:03
Se la pasamos 00:22:04
¿Qué hace? 00:22:05
Te pide el tipo de cliente 00:22:06
Te pide los datos comunes 00:22:08
Luego 00:22:10
Prepara un objeto 00:22:11
Para meter el cliente 00:22:13
El online o tienda 00:22:14
Depende del que tú quieras 00:22:15
Lo deja ahí preparado 00:22:16
Lo deja ahí preparado 00:22:17
Ahora 00:22:18
Que el tipo es igual a 1 00:22:19
Pido el dato adicional 00:22:20
Y construyo a este 00:22:22
Adiós 00:22:24
Que no es igual a 1 00:22:26
Pido el dato adicional 00:22:27
Y construyo el otro 00:22:29
Y ahora 00:22:30
Si el tipo era igual a 1 00:22:32
Asigna ct 00:22:34
A la posición adicional 00:22:36
Y si no 00:22:37
Asigna ceo 00:22:39
¿Vale? 00:22:39
En principio 00:22:41
El método 00:22:42
Hasta donde yo sé 00:22:42
Ya está 00:22:45
¿Vale? 00:22:46
Quito esto de aquí 00:22:47
Y ya está 00:22:48
Pero me está dando 00:22:48
En el momento 00:22:52
Para ejecutarlo 00:22:53
O en el compilador 00:22:54
Pero que error te da 00:22:55
De compilación 00:23:01
¿Qué te dice? 00:23:01
¿Se lo has pasado 00:23:13
Como parámetro? 00:23:13
Vale 00:23:18
Bueno pues ya está 00:23:22
Este método 00:23:26
Mete un cliente 00:23:27
Independientemente del tipo que sea 00:23:28
Pues ya 00:23:30
Nuestro main 00:23:31
Pasará a la cajita 00:23:32
Y meterá al cliente 00:23:34
Vale 00:23:35
Entonces 00:23:35
Esta aplicación 00:23:38
La estamos haciendo 00:23:40
En lugar de como la anterior 00:23:40
Que la anterior 00:23:42
La estábamos haciendo 00:23:43
Hacer 00:23:44
Bueno es que yo aquí 00:23:45
La tengo 00:23:47
La tengo a medio tiempo 00:23:47
Hacer un array de 100 00:23:48
Y luego una variable posición 00:23:49
Y rellenando 00:23:51
Pues esta ya es más bonita 00:23:53
Esta nueva que estamos haciendo 00:23:54
Es un array 00:23:56
Esto no es 00:23:57
Esta nueva que estamos haciendo 00:24:00
Es un array que se va estirando 00:24:02
Inicialmente tiene cero clientes 00:24:04
Inicialmente tiene cero 00:24:06
Y luego ya vamos metiendo en él 00:24:06
Con lo cual esta variable post 00:24:08
Nos sobra 00:24:09
Esta que yo he puesto aquí 00:24:10
Con esta opción nos sobra 00:24:11
Vale 00:24:13
Insertar cliente 00:24:14
Bueno 00:24:16
Hasta ahí 00:24:16
Vale 00:24:18
Entonces ahora vamos a 00:24:18
A meter una segunda funcionalidad 00:24:21
A nuestro 00:24:26
A nuestra 00:24:29
A nuestra aplicación de gestión 00:24:31
Que es 00:24:33
Enviar pedido a un cliente 00:24:35
Dado su NIF 00:24:37
Vale 00:24:38
Vale 00:24:39
Vamos a meter 00:24:47
Una segunda funcionalidad 00:24:48
Que es 00:24:49
Oye 00:24:49
Yo te doy el NIF 00:24:50
De un cliente 00:24:52
Tienes que enviarle el pedido 00:24:55
Por email 00:24:57
Por dirección 00:25:00
Pues yo que sé 00:25:01
Como sea 00:25:02
Ambos tienen la opción 00:25:02
De enviar pedido 00:25:03
¿Verdad? 00:25:04
Enviar pedido en cliente tienda 00:25:05
Funciona de una manera 00:25:06
Y en cliente online 00:25:07
Funciona de otra 00:25:09
Pero ambos tienen su método 00:25:09
Enviar pedido 00:25:11
Porque lo hemos hecho 00:25:11
¿Verdad? 00:25:12
Bueno 00:25:14
Vamos a incorporar esa funcionalidad 00:25:15
Yo te doy un NIF 00:25:16
Y me busco 00:25:17
Pues venga 00:25:18
Vamos a hacer el caso 2 00:25:19
Vale 00:25:21
Pues vamos a hacerlo también 00:25:27
A través de un método auxiliar 00:25:29
Operaciones 00:25:30
Donde le vamos a llamar 00:25:33
Enviar pedido 00:25:36
Tendrá que solicitar un NIF 00:25:43
Recorrer el array de clientes 00:25:45
Entonces 00:25:48
Vamos a dejar ahora vacío 00:25:49
Que le vamos a pasar a este parámetro 00:25:53
Hasta que luego lo decidamos 00:25:55
Entonces vamos a 00:25:56
Construir 00:25:58
Bueno 00:26:00
Si lo pedimos dentro de enviar pedido 00:26:01
Hay dos opciones 00:26:03
Que lo pidamos aquí 00:26:04
Introduzca el NIF 00:26:05
Y luego se lo pasemos 00:26:05
O que dentro del propio enviar pedido 00:26:06
Hagamos 00:26:08
Introduzca NIF 00:26:08
Entonces no haría falta 00:26:09
Depende de la opción que tomamos 00:26:10
¿Vale? 00:26:12
Vamos a suponer 00:26:12
Para que esto nos quede más cortito 00:26:13
Que nuestro método enviar pedido 00:26:14
Este de aquí 00:26:17
Public 00:26:18
Static 00:26:19
Void 00:26:20
Enviar pedido 00:26:22
Este dentro de aquí 00:26:23
Pues este ya va a solicitar el NIF 00:26:26
Va a decir 00:26:31
Introduzca NIF 00:26:31
Lo lee él y todo eso 00:26:32
Introduzca NIF del cliente 00:26:34
Al que va a enviar el pedido 00:26:39
Pues nada 00:26:41
Leería el NIF 00:26:43
Entonces no hay que pasárselo por parámetro 00:26:44
Porque lo lee él dentro 00:26:46
Leer NIF que es cadena 00:26:48
Vale 00:26:55
Pero claro 00:26:56
Ahora que tiene que hacer este método 00:26:57
Tiene que ponerse a recorrer 00:26:59
El array de clientes 00:27:01
Hasta encontrar el cliente con ese NIF 00:27:03
Y cuando lo ha encontrado 00:27:05
Llamar al método enviar pedido de ese cliente 00:27:06
Porque recordad que el cliente 00:27:09
Tanto si es de tienda 00:27:12
Como si es online 00:27:14
Tiene su método enviar pedido 00:27:15
Que hemos hecho para enviarle su pedido 00:27:18
Ambos tienen esa opción 00:27:19
Bueno pues este método entonces 00:27:20
Ahora tendrá que buscar el array 00:27:23
Nuevo 00:27:25
Que necesita que se le pase por parámetro 00:27:26
El array 00:27:29
No el NIF 00:27:32
Si lo siguiente que tiene que hacer 00:27:33
Es buscar 00:27:37
En el array de clientes 00:27:38
Estamos en la misma situación de arriba 00:27:40
Como 00:27:43
¿Eh? 00:27:44
La de 00:27:46
¿Eh? 00:27:47
O sea que se lo tendremos que pasar por parámetro 00:27:48
Pues eso 00:27:51
La misma situación 00:27:52
Entonces 00:27:53
¿Qué es lo que nos falta? 00:27:53
¿Qué necesita este método? 00:27:55
El NIF no porque lo lee desde dentro 00:27:56
Pero la caja de clientes para buscar 00:27:57
La necesita ¿no? 00:28:00
Yo no puedo buscar un cliente 00:28:01
En una caja que tengo fuera 00:28:02
Me tendrán que meter la caja 00:28:03
Yo ya busco el cliente 00:28:04
Y te hago lo que sea 00:28:05
Pero si no me la das 00:28:06
Pues lo mismo 00:28:07
Claro porque no tiene acceso a esa variable 00:28:09
Esa variable es una variable local de otro método 00:28:13
Entonces no puedes acceder a una variable local de otro método 00:28:15
Entonces no puedes acceder a una variable local de otro método 00:28:17
Entonces no puedes acceder a una variable local de otro método 00:28:17
Entonces si 00:28:17
Se la tienes que pasar 00:28:18
Si no se la pasas 00:28:20
Vale pues entonces le tendremos que pasar la cajita 00:28:21
Se la tendremos que pasar 00:28:27
Y ahora ya aquí buscará 00:28:29
Vale ahora ya 00:28:32
Ahora ya podemos buscar el array 00:28:47
Porque el array nos lo han pasado 00:28:49
Nos lo han pasado por aquí 00:28:51
Y ahora ya nuestro main 00:28:52
Lo pasará por aquí 00:28:54
Clientes 00:28:56
Vale 00:28:57
Y a nosotros ya pues muy chulos 00:29:02
Pues hacemos venga 00:29:05
Si clientes de i 00:29:06
Si clientes de i.getNIF 00:29:09
Si clientes de i.getNIF 00:29:13
Si clientes de i.getNIF 00:29:13
Si clientes de i.getNIF 00:29:13
Si clientes de i.getNIF 00:29:13
Si clientes de i.getNIF 00:29:15
El NIF que acabo de leer 00:29:17
El NIF que acabo de leer 00:29:21
Estupendo ya hemos encontrado el cliente 00:29:22
Para el cual hay que enviar el pedido 00:29:26
Entonces yo me hago clientes de i 00:29:28
E intento darle al método 00:29:29
Enviar pedido 00:29:32
No porque hemos dicho 00:29:33
Este array tiene objetos 00:29:39
Cliente tienda cliente online 00:29:40
Del tipo que sea 00:29:42
Me caben los dos en el array 00:29:43
Porque hemos dicho que es un array de la clase 00:29:45
Cliente 00:29:47
Con lo cual le caben objetos 00:29:48
De cualquiera de las subclases 00:29:50
Bueno pues entonces 00:29:52
Yo no sé que tiene este array 00:29:54
Pero sé que tiene 00:29:56
Clientes tienda clientes online 00:29:57
Sé que los tiene 00:29:59
Y cliente tienda tiene enviar pedido 00:30:00
Que se lo acabo de ver aquí 00:30:03
Y cliente online tiene enviar pedido 00:30:04
Ambos lo tienen 00:30:07
Claro entonces 00:30:08
Entonces este objeto me está diciendo 00:30:10
Lo siento 00:30:14
Enviar pedido no existe 00:30:17
Es lo que nos está diciendo 00:30:17
Enviar pedido no existe 00:30:18
Vale 00:30:20
Entonces esto diríamos 00:30:22
Jolín pero que absurdo 00:30:23
Claro que el objeto este lo tiene 00:30:24
Por supuesto que lo tiene 00:30:27
Porque este objeto no hay tu tía 00:30:29
O es cliente tienda o es cliente online 00:30:31
Yo sé que lo tiene 00:30:34
Yo sé que lo tiene 00:30:35
Claro tú lo sabes 00:30:36
Pero el compilador no 00:30:38
Que fastidia 00:30:40
El compilador dice yo no sé que has metido tú ahí 00:30:42
Pero yo sé 00:30:45
Que este array clientes 00:30:47
Es de la clase cliente 00:30:48
Y eso significa 00:30:50
Que cualquiera que herede de cliente 00:30:52
Puede llamar al método 00:30:55
Cliente tienda por supuesto 00:30:57
Cliente online por supuesto 00:30:59
Pero cualquier otro 00:31:00
Y como tengo yo la garantía de que ese cualquier otro 00:31:02
Tenga un método de enviar pedido 00:31:05
No la tengo 00:31:06
Entonces lo que te dice es 00:31:07
Oye ojo 00:31:09
Si tú te haces un array de la clase cliente 00:31:09
El método al que llames 00:31:12
Que esté declarado en la clase cliente 00:31:15
No solo en las subclases 00:31:16
También en la superclase 00:31:21
Porque qué pasa 00:31:23
Si luego yo le hago un parche a la aplicación 00:31:24
Y me hago un cliente 00:31:27
No sé qué 00:31:29
Y ese cliente no sé qué no tiene enviar pedido 00:31:30
Pues he quitado la coherencia de la aplicación 00:31:32
Porque ese cliente no sé qué 00:31:35
Podría caer en el array perfectamente 00:31:37
Porque es una subclase 00:31:39
Podría caer 00:31:40
Pero ese no tiene enviar pedido 00:31:40
Entonces la obligación que tenemos 00:31:42
Ahora es que 00:31:45
Ahora es 00:31:46
Oye si tú quieres llamar a un método 00:31:47
Enviar pedido 00:31:49
Y teniendo en cuenta que este array 00:31:51
Está declarado de clase cliente 00:31:54
Ese método tiene que estar en la clase cliente 00:31:57
Lo siento 00:32:00
No hay otra 00:32:00
Si no te haces dos arrays 00:32:01
Te haces un cliente tienda 00:32:03
Y ahí podrás llamar sin ningún problema a enviar pedido 00:32:05
Porque el array está declarado como cliente tienda 00:32:07
Y te haces luego un cliente online 00:32:09
Y ahí podrías llamar a enviar pedido 00:32:11
Porque enviar pedido está en cliente online también 00:32:13
Pero como te hagas un parche a la aplicación 00:32:15
Y haces un array cliente 00:32:16
Solo puedes llamar a lo que esté en cliente 00:32:17
Y ahí no hay ningún enviar pedido 00:32:21
Pues eso es lo que nos está diciendo 00:32:23
¿Vale? 00:32:25
Y tiene sentido que se proteja 00:32:26
Entonces nosotros empezamos a buscar la solución 00:32:27
Y decimos 00:32:30
Vale pues ven 00:32:32
Vamos a hacer enviar pedido en cliente 00:32:33
Para que te calles 00:32:35
Entonces nos metemos aquí a hacer un enviar pedido 00:32:37
Public void 00:32:40
Enviar pedido 00:32:43
Enviar pedido 00:32:46
Y aquí ya 00:32:50
Otra vez nos quedamos atascados 00:32:52
Enviar pedido 00:32:55
Vamos a ver 00:32:57
En esta clase cliente enviar pedido 00:32:58
Pero como si no tengo información 00:33:00
Esta es la clase genérica 00:33:01
Que solo tiene el mismo nombre 00:33:04
Aquí no hay dirección, aquí no hay tienda, aquí no hay presencial 00:33:05
Enviar pedido ¿Qué hago con enviar pedido? 00:33:08
No puedo 00:33:12
No tengo información 00:33:12
Es que no sé 00:33:13
No tengo dirección, no tengo email 00:33:14
No tengo información 00:33:16
No tengo, no puedo hacerlo 00:33:16
O sea me obligas a hacer un método para poder llamarlo 00:33:18
Y cuando me voy a hacerlo 00:33:20
Es que no tiene sentido 00:33:22
Porque enviar pedido tiene sentido 00:33:24
Que se haga en las subclases 00:33:26
Cuando ya sé si es de tienda o es online 00:33:27
Pues efectivamente no tiene sentido 00:33:30
No puedo hacerlo 00:33:33
Luego ¿Qué hago? 00:33:34
Lo dejo vacío 00:33:36
Lo dejo vacío porque no puedo hacerlo 00:33:36
No tengo información 00:33:40
Lo dejo vacío, genial 00:33:41
Lo dejo vacío 00:33:43
Y ahora este ya se queda tan ancho 00:33:44
Ay que bien 00:33:46
Tienes ya un enviar pedido en cliente 00:33:47
Te dejo que lo llames 00:33:49
Y ahora me diríais 00:33:51
Jue, pues vaya tontería 00:33:55
¿Y ahora qué va a pasar? 00:33:56
¿Se va a llamar el enviar pedido de cliente? 00:33:58
Entonces no va a hacer nada 00:34:00
Pues no 00:34:01
Porque en el momento de ejecutar 00:34:03
Al método que se llama 00:34:07
Es al de la subclase 00:34:09
Luego 00:34:11
Tenéis que distinguir 00:34:14
Fasa de compilación 00:34:16
Tiempo de compilación que se llama 00:34:18
Uno está desarrollando su código 00:34:20
Y ahí tiene que seguir las reglas del juego 00:34:22
Tiene que seguirlas 00:34:24
Y las reglas del juego me dicen 00:34:26
Oye yo tengo que fijar unas reglas 00:34:28
Y si tú me has dicho que en este array 00:34:31
Puede haber cualquier tipo de cliente 00:34:33
Cualquier tipo 00:34:35
Yo tengo que asegurarme 00:34:36
De que en cualquier tipo de cliente 00:34:37
Hay un método de enviar pedido 00:34:39
Porque si no 00:34:41
¿Cómo sé yo que luego no vas a meter un objeto 00:34:41
De un tipo? 00:34:45
Cualquier cliente que lo tenga 00:34:46
¿Cómo lo sé yo? 00:34:47
Me tengo que asegurar 00:34:48
Mi única manera de asegurarme 00:34:49
De que en todo va a haber enviar pedido 00:34:51
Es que me lo hagas en la superclase 00:34:52
Porque si me lo haces en la superclase 00:34:54
Te lo darán todas 00:34:55
Es mi única forma de asegurarse 00:34:56
Entonces tienes que seguir las reglas del juego 00:34:57
Vale, la sigo 00:34:59
Y me hago un enviar pedido en cliente 00:35:00
Tiempo de compilación 00:35:02
Ahora ya pasamos al tiempo de ejecución 00:35:04
Esta aplicación se ejecuta 00:35:05
Ahora ya el compilador ya no entra en juego 00:35:07
Se acabó 00:35:11
Ahora entra en juego la máquina virtual 00:35:11
La máquina virtual empieza a ejecutar 00:35:13
La máquina virtual empieza a ejecutar 00:35:16
La máquina virtual empieza a ejecutar 00:35:16
La máquina virtual empieza a ejecutar 00:35:16
Y ahora ya como estamos en tiempo de ejecución 00:35:16
Ya el array tiene cosas 00:35:19
Ya tiene cosas 00:35:20
Ya tiene objetos concretos 00:35:22
Tiene a lo mejor 3 clientes tienda 00:35:24
Luego 2 clientes online 00:35:26
Luego otro cliente tienda 00:35:27
Ya tiene objetos 00:35:28
Porque ya estamos en tiempo de ejecución 00:35:29
Y ahora está la máquina virtual jugando 00:35:31
El compilador ya dejó de jugar 00:35:34
Porque ya hemos compilado todo perfecto 00:35:36
Ahora está la máquina virtual 00:35:37
La máquina virtual ya tiene un array concreto 00:35:39
Y empieza a recorrerlo 00:35:42
Dice venga 00:35:43
Este cliente coincide es un if 00:35:43
Muy bien 00:35:46
Pues voy a llamar al método de enviar pedido 00:35:47
Pero la máquina virtual lo que hace es decirse 00:35:49
Oye 00:35:51
Este objeto concreto 00:35:51
Cuando se ha creado 00:35:53
¿De qué tipo se ha creado? 00:35:55
¿Se ha creado como tienda o como online? 00:35:57
Porque yo voy a llamar 00:36:01
Al método que esté en la versión de la clase 00:36:02
Como se ha creado 00:36:05
Como se ha creado 00:36:06
Porque la máquina virtual juega ya en tiempo de creación de objetos 00:36:08
De ejecución 00:36:11
Luego 00:36:12
Si clientes de ahí coincide 00:36:15
Que se creó y existe 00:36:17
Como cliente tienda 00:36:19
Porque en el momento de crearse 00:36:20
Se creó como cliente tienda 00:36:22
La versión de enviar pedido a la que se llame 00:36:23
Será la que esté en cliente tienda 00:36:26
Pero si clientes de ahí 00:36:29
Coincide que se creó en el momento de añadirlo 00:36:31
Se creó como cliente online 00:36:33
La versión de enviar pedido 00:36:35
A la que llama la máquina virtual 00:36:37
Es a la que hay en cliente online 00:36:38
¿Vale? 00:36:40
Luego distinguir la fase de compilación 00:36:42
Se juega con unas reglas 00:36:45
Y la fase de ejecución 00:36:47
Y tiene todo el sentido del mundo 00:36:48
Que esté así hecho la cosa 00:36:50
¿Vale? 00:36:51
Entonces, aunque aquí haya un enviar pedido 00:36:55
En blanco 00:36:57
Este enviar pedido 00:36:59
Está hecho simplemente 00:37:01
Para generar una obligación 00:37:02
Y dices 00:37:04
Yo cliente te obligo 00:37:06
A cliente tienda 00:37:08
Cliente online, cliente patatín 00:37:10
Cliente patatón 00:37:12
Te obligo a que hagas un método enviar pedido 00:37:13
Y tú ya le rellenas como te dé la gana 00:37:16
Yo te doy 00:37:18
Te genero la obligación 00:37:20
De alguna manera 00:37:22
No es que sea una obligación 00:37:23
Te doy las pautas de que si eres un cliente 00:37:24
Hombre, pues si eres un cliente 00:37:27
Interesa que tengas un enviar pedido 00:37:29
Pero yo aquí lo dejo en blanco 00:37:30
Pero hago como una especie de plantilla 00:37:32
Y digo, todos los clientes 00:37:36
Tiene sentido que tengan un enviar pedido 00:37:38
Pues yo aviso de eso 00:37:40
Aviso de eso 00:37:42
Poniéndolo en blanco 00:37:42
Y ahora ya, cuando el programador 00:37:43
Se pone a heredar de cliente 00:37:46
Dice, me voy a hacer mi propia versión 00:37:48
De enviar pedido 00:37:50
Ahora yo me hago mi propia versión 00:37:51
Entonces esto es una especie de marco 00:37:52
De significado de las cosas 00:37:56
Si hemos acordado que a los clientes 00:37:58
Les pueden enviar pedidos 00:38:00
Pues vamos a indicar eso de alguna manera 00:38:01
Poniéndolo en la superclase 00:38:04
Y entonces ya las subclases 00:38:06
Cada una da su propia versión 00:38:08
Cada una da su propia versión 00:38:10
Cliente online da su versión 00:38:12
Que es esta 00:38:16
Y cliente tienda da su versión 00:38:17
Que es esta 00:38:20
Y luego ya la máquina virtual 00:38:20
Cuando ya entre a jugar la máquina 00:38:22
Porque ya esto se está ejecutando 00:38:24
Pues la máquina virtual ya 00:38:26
Ya decidirá 00:38:28
Dirá, venga, este, ¿qué es? 00:38:31
Este se instanció o se creó como tienda 00:38:34
Pues llama a la versión que está en tienda 00:38:37
Se instanció como no sé qué 00:38:39
Pues llama a la versión 00:38:41
De la tienda 00:38:42
De no sé qué 00:38:42
¿Vale? 00:38:43
Bueno, pues esto es importantísimo entenderlo 00:38:49
Esto es lo que se llama 00:38:51
La sobrescritura de métodos 00:38:52
El método está en la clase padre 00:38:55
Y se hereda 00:38:58
Pero se hereda vacío 00:39:00
Que tú lo quieres tener vacío 00:39:01
En tu clase heredera 00:39:03
Pues lo dejas vacío 00:39:03
Pero que tú quieres tu propia versión 00:39:05
De enviar pedido 00:39:07
Pues la sobrescribes 00:39:08
Y sobrescribirlo es 00:39:10
Hacer uno igualito 00:39:12
Con la misma cabecera 00:39:14
Hacer uno igualito 00:39:15
Entonces te haces tu propia versión 00:39:16
Como subclase te haces tu propia versión 00:39:18
Con lo cual estás pisando el heredado 00:39:21
Si yo no me hiciera esta versión 00:39:22
De aquí 00:39:25
En cliente tienda 00:39:26
En cliente online que estoy 00:39:29
Si yo no me la hago 00:39:32
Esta tiene la heredada 00:39:34
La tiene 00:39:35
Porque se hereda todo 00:39:36
Y la heredada sería 00:39:37
Estaría heredando un vacío 00:39:39
Vale, pues se hereda un vacío 00:39:40
Pero normalmente 00:39:41
Normal es que las subclases 00:39:42
Quieran ya dar un funcionamiento 00:39:44
Concreto a las acciones 00:39:46
Y entonces la cliente tienda dice 00:39:47
O cliente online dice 00:39:49
No, no, no 00:39:51
Oye 00:39:51
Yo quiero mi propia versión 00:39:52
De enviar pedido 00:39:54
Entonces me hago ese método 00:39:55
Con la misma cabecera 00:39:57
Y ya le meto 00:39:57
Lo que yo quiero en concreto 00:39:58
Y ahora ya 00:40:00
Cuando los objetos 00:40:02
Llamen a enviar pedido 00:40:03
Aunque se han declarado como cliente 00:40:04
Si en el momento de crearlo 00:40:06
Se han creado 00:40:08
Como cliente tienda 00:40:09
La versión del método 00:40:10
Que se llama 00:40:12
Es el método de enviar pedido 00:40:12
Que pasa esto 00:40:12
Vale 00:40:13
Entonces hemos sobre escrito el método 00:40:14
Y este es el famoso 00:40:16
Polimorfismo de la programación 00:40:19
En todo objeto 00:40:20
Es esto 00:40:21
Entonces uno se pone a estudiar 00:40:23
Polimorfismo es esto 00:40:24
Bla, bla, bla, bla, bla 00:40:25
Pues viene de esta motivación 00:40:26
Viene 00:40:28
De que 00:40:28
Este método 00:40:30
Enviar pedido de aquí 00:40:32
Nos parece 00:40:34
Que estamos llamando 00:40:35
Al mismo código 00:40:37
Por hacer esta llamada 00:40:38
¿A qué código estamos llamando? 00:40:40
Depende de la forma 00:40:42
De ahí la palabra 00:40:44
Polimorfismo 00:40:45
Del objeto que lo llama 00:40:46
Que este objeto es cliente tienda 00:40:47
Este se va al código de cliente tienda 00:40:50
Que este objeto adopta otra forma 00:40:54
Y ahora es cliente online 00:40:56
Este método 00:40:57
Es el de cliente online 00:40:58
Esto es el concepto de polimorfismo 00:41:00
De la programación de antavos objetos 00:41:04
Una llamada a un método 00:41:05
De la clase cliente 00:41:07
O es 00:41:08
Una forma en concreto 00:41:10
O es otra forma 00:41:12
En función del objeto que lo llame 00:41:13
Porque cada objeto 00:41:15
Lo habrá sobrescrito a su manera 00:41:16
¿Vale? 00:41:17
Vale, bueno 00:41:22
Pues vamos a dejarlo aquí 00:41:23
Entonces 00:41:25
Todo por favor 00:41:27
Yo luego cuando llegue a casa 00:41:29
Subo las grabaciones y el proyecto 00:41:31
Y todo lo 00:41:33
Estoy 00:41:36
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
2 de febrero de 2024 - 18:16
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
41′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
189.50 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid