Saltar navegación

Ejercicio Herencia-abstract-polimorfismo - 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 9 de febrero de 2024 por Stefano C.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, por tanto todo lo que decís será grabado en mis vídeos 00:00:00
Vale, entonces estamos creando este producto 00:00:07
Tiene estas características, tiene un método que es una descripción del producto en general 00:00:10
Y luego tiene un coste, vale 00:00:15
Este coste es abstracto, para repasar que quiere decir abstracto, vale 00:00:19
El hecho de que la clase sea abstracta quiere decir que no puedo crear una instancia de esta clase, vale 00:00:24
Y que esta clase tendrá algunos métodos que son abstractos a su vez 00:00:31
Este abstracto es como si yo estuviera creando un contrato, vale 00:00:36
En el que digo, vale, existe este método, el método coste 00:00:41
Pero yo no te digo cómo se implementa 00:00:45
No hay una implementación real del método coste, vale 00:00:48
Cuando alguna clase 00:00:53
Futuramente 00:00:54
Extenderá mi clase producto 00:00:55
Si es la clase que extiende producto 00:00:59
Es una clase 00:01:01
No abstracta 00:01:03
Tendrá necesariamente que 00:01:05
Implementar este método, vale 00:01:08
Es como si 00:01:12
Una forma para estar seguro 00:01:13
Que cualquier clase que extiende producto 00:01:16
Y que no sea abstracta 00:01:18
Pues tiene que implementar este método 00:01:20
Tendrá este método seguramente 00:01:22
Porque si no, no se va a poder hacer nada 00:01:23
Daría un error 00:01:24
Vale 00:01:24
Es una generalización 00:01:26
Es decir, todos los productos tendrán una forma de pedir su coste 00:01:28
Pero como no sé de qué producto estamos hablando 00:01:32
No te puedo decir cómo se hace esta cosa 00:01:35
Entonces, la dejo al futuro 00:01:37
La dejo a cuando extenderé esta clase 00:01:40
Creando una clase más concreta 00:01:44
Esa clase concreta tendrá un método concreto para calcular su coste 00:01:45
Y lo tendrá que implementar 00:01:50
¿Se entiende esto? 00:01:51
Sí 00:01:52
¿Sí? 00:01:52
Pues nada 00:01:54
Entonces veis que está a punto de coma aquí 00:01:55
No tiene cuerpo 00:01:57
Pues está vacío 00:01:58
¿Sí? 00:02:00
Voy a extender un poquito esto 00:02:02
¿No? 00:02:06
Que chulo 00:02:07
Nuevo 00:02:07
Clase 00:02:16
Creo una clase 00:02:17
Que es una subclase de esto, ¿vale? 00:02:18
Que es la clase servicio 00:02:20
Vale 00:02:24
La clase servicio 00:02:26
Para mí 00:02:28
Extends 00:02:29
Producto 00:02:30
Ok, fijaos que me da un error 00:02:33
Y este error es 00:02:39
El tipo servicio tiene que implementar 00:02:42
El método abstracto heredado 00:02:45
Que es producto.coste 00:02:49
¿Sí? 00:02:51
Fijaos que si esta fuera abstracta también 00:02:52
Este problema no está 00:02:54
¿Sí? 00:02:57
Yo a este punto estoy heredando este método abstracto 00:02:59
Pero no necesariamente tengo que implementarlo 00:03:02
Podría implementarlo 00:03:07
Podría ser servicio que lo implementa 00:03:08
Y luego tenga otros métodos abstractos 00:03:10
Podría 00:03:12
Si la clase producto tuviera cinco métodos abstractos 00:03:12
Podría ser que la clase servicio implemente tres de estos 00:03:17
Dos los deje abstractos 00:03:21
Y añade dos que son abstractos para sus hijos 00:03:23
No sé si me explico lo que quiero decir 00:03:26
¿Vale? 00:03:28
No hay una limitación de 00:03:29
Ah, no, como es extendido y eres abstracta 00:03:30
Pues tienes que implementar todo 00:03:32
Y luego poner otros 00:03:33
O no puedes poner otros 00:03:34
Puedes hacer un poco lo que necesites 00:03:36
¿Sí? 00:03:38
Pero en nuestro caso no es abstracta 00:03:39
Es concreta esta clase 00:03:41
¿Vale? 00:03:44
Entonces por algún lado aquí tendré que 00:03:44
¿Cómo se dice? 00:03:47
Implementar el método que hemos dicho 00:03:50
¿Vale? 00:03:52
El método que hemos dicho 00:03:53
El método está aquí 00:03:53
El coste 00:03:54
Vale, aquí no he creado un constructor 00:03:55
Por lo tanto si os fijáis aquí no se queja del constructor 00:04:00
Primeramente si yo hiciera aquí public int coste 00:04:03
Return 1 00:04:09
Pues ya está 00:04:12
Él ahora está contento 00:04:13
¿Vale? 00:04:15
Puede utilizar el constructor 00:04:16
Le he implementado el coste que era abstracto antes 00:04:18
Y ahora es concreto 00:04:21
Por lo tanto he hecho 00:04:23
He cumplido con el contrato en un cierto sentido 00:04:24
Que me decía la clase abstracta 00:04:28
Y ya está 00:04:29
¿Vale? 00:04:30
Sin embargo necesitaría rellenar estas cosas 00:04:32
¿Vale? 00:04:35
Entonces aquí creo un constructor 00:04:36
Public 00:04:38
Producto 00:04:40
Bueno, hagámoslo de otra forma 00:04:42
Botón derecho 00:04:45
Este es source 00:04:47
Generate constructor using fields 00:04:53
Lo que quiero construir es un constructor que use 00:04:57
El nombre, el precio y la descripción 00:05:01
El código no 00:05:07
¿Vale? 00:05:07
Y él me crea 00:05:15
Producto con estas cosas aquí 00:05:16
¿Por qué el código no? 00:05:18
Porque me gustaría que el código fuera único 00:05:20
¿Vale? 00:05:22
Que fuera algo que no me viene dado desde el constructor 00:05:23
Que luego a lo mejor crea un producto y lo crea mal 00:05:28
¿Vale? 00:05:30
Sino que cada producto tenga su propio valor distinto de los demás 00:05:31
¿Vale? 00:05:37
Fijaos en una cosa interesante que es 00:05:38
Oye, mira, esta es una clase abstracta 00:05:41
Y yo no puedo crear objetos producto 00:05:43
Sin embargo tiene un constructor 00:05:46
Constructor 00:05:48
El objetivo del constructor es 00:05:50
Crear objetos de ese tipo 00:05:52
Es una cosa un poco rara 00:05:54
¿Vale? 00:05:56
Pero no es absurda en el sentido 00:05:57
Este de aquí no lo usaré nunca directamente 00:06:00
Pero sí lo podré usar desde las subclases 00:06:03
Como super constructor 00:06:06
¿Sí? 00:06:07
Por eso tiene sentido que esté aquí 00:06:09
¿Dudas? 00:06:11
Vale, ¿cómo? 00:06:13
Creo 00:06:16
El código 00:06:16
Para que sea único 00:06:19
Pues, por ejemplo, me puedo hacer una 00:06:22
Una variable 00:06:26
Estática 00:06:27
De producto 00:06:30
static int 00:06:32
O de 00:06:35
Que al principio vale cero 00:06:40
¿Vale? 00:06:42
Y aquí 00:06:46
This.código 00:06:47
Es igual a 0 00:06:50
Es igual a 0 00:06:51
Es igual a 0 00:06:51
Es igual a 0 00:06:51
Es igual a 0 00:06:51
Es igual a 0 00:06:51
Es igual a 0 00:06:51
Es igual a 0 00:06:52
Es igual a 0 00:06:52
Es igual a 0 00:06:52
Es igual a 0 00:06:52
Es igual a 0 00:06:53
Es igual a 0 00:06:53
Es igual a 0 00:06:54
Es igual a 0 00:06:55
Ten en cuenta que código 00:06:58
Es un 00:07:00
String 00:07:02
Por lo tanto transformo este valor de aquí 00:07:03
En comillas 00:07:07
En un string 00:07:08
Y para que sea siempre distinto 00:07:11
Y para que alguien desde fuera 00:07:13
No me moleste 00:07:19
Me seguís 00:07:22
Si yo lo dejo así 00:07:25
Cualquiera puede acceder a producto.code 00:07:28
Y volver a ponerlo a cero 00:07:30
Y entonces ya no tengo los productos únicos 00:07:32
Si lo pongo así 00:07:34
Private 00:07:36
Ahora esta cosa de aquí solo se puede modificar 00:07:37
Internamente en esta clase de aquí 00:07:40
Y solo se modifica aquí 00:07:42
Sumando uno, cada vez que creo un producto nuevo 00:07:44
Por lo tanto 00:07:46
No debería tener problemas 00:07:47
¿Si? 00:07:49
Tened en cuenta también que todas estas de aquí 00:07:50
También deberían ser privados 00:07:53
Probablemente para no ser accedido desde fuera 00:07:55
Y hacer cosas raras 00:07:58
O como mínimo 00:07:59
Protected 00:08:00
Para que mis hijos 00:08:01
Si la puedan utilizar y modificar 00:08:04
Pero fuera de la 00:08:06
Cadena de herencia y fuera del 00:08:09
Package que estoy produciendo yo 00:08:10
Pues no, no sea posible modificar 00:08:12
Estos datos de aquí 00:08:14
Para simplicidad por ahora lo dejamos así 00:08:15
Que si no luego tendríamos que hacer gettys 00:08:18
Set y cosas por eso 00:08:20
Vale 00:08:21
Ahora me da problemas 00:08:23
Aquí 00:08:28
Porque al haber hecho la creación 00:08:29
De este producto aquí, de este constructor 00:08:32
Pues he quitado el constructor 00:08:34
Por defecto, al haber quitado el constructor 00:08:36
Por defecto 00:08:38
Pues no puedo utilizar 00:08:39
Aquí el constructor por defecto mismo 00:08:42
Porque el constructor por defecto de servicio 00:08:44
Llamaría a super 00:08:46
Sin parámetros 00:08:48
Entonces tengo que acceder a un public 00:08:49
Servicio 00:08:52
Que pilla la cosa 00:08:53
Vale 00:08:57
Tened en cuenta también que servicio 00:08:59
Decíamos que tiene una cosa que es 00:09:02
Tiempo 00:09:04
Que 00:09:05
Sostancialmente es 00:09:08
Cuantos meses 00:09:09
Dura este servicio 00:09:11
Yo digo tres meses 00:09:15
Tres meses 00:09:19
Tres meses 00:09:19
Pues si tiempo es tres 00:09:19
Que este servicio ha sido contratado por tres meses 00:09:21
¿Sí? 00:09:23
Entonces 00:09:25
¿Qué recibe 00:09:26
Servicio como constructor? 00:09:27
Pues 00:09:31
Tened en cuenta que yo no crearé nunca 00:09:32
Un producto 00:09:35
Siempre crearé un servicio por ejemplo 00:09:36
Si quiero un servicio 00:09:39
Entonces estas cosas aquí las necesito 00:09:40
Y también 00:09:44
Intertiempo 00:09:46
¿Sí? 00:09:49
¿Qué hará este servicio? 00:09:50
Llamar super 00:09:55
De nombre 00:09:56
Precio 00:09:58
Y desk 00:09:59
Ahora estoy llamando 00:10:02
El constructor de la super clase 00:10:07
Con estos parámetros de aquí 00:10:10
Que se referirá a este constructor 00:10:11
Por lo tanto se hará esta cosa de aquí 00:10:14
¿Vale? 00:10:16
¿Vale? 00:10:17
Y luego 00:10:17
Pasaré a modificar 00:10:21
Las cosas propias 00:10:25
Del servicio 00:10:27
¿Sí? 00:10:28
Como por ejemplo 00:10:29
Dis.tiempo 00:10:30
Es igual a tiempo 00:10:32
Cosas que no estaba 00:10:33
En el mundo 00:10:37
Anterior 00:10:39
En producto tiempo no existe 00:10:40
¿Vale? 00:10:42
Por lo tanto me creo 00:10:43
Esto es como decir 00:10:44
Haz todo lo que harías para un producto 00:10:45
Porque esto es un producto 00:10:47
O sea, acuérdate que 00:10:49
Servicio es un producto 00:10:49
Y luego después 00:10:51
Esto de aquí 00:10:52
¿Vale? 00:10:53
Y también 00:10:54
Quiero hacer otra cosa 00:10:55
Que es 00:10:57
Dis.código 00:10:57
Es igual a 00:10:58
Dis.código 00:11:01
Se llama código 00:11:02
Dis.código 00:11:04
Pero no me lo pilla 00:11:11
Por alguna razón 00:11:12
Lo haremos así 00:11:13
Se haga así 00:11:13
Pero delante 00:11:14
Del código 00:11:17
Le sumo 00:11:18
Un S 00:11:21
Es decir 00:11:22
Que el producto es único 00:11:25
Y tendrá 1, 2, 3, 4, 5, 6, 7 00:11:26
Pero si hago un servicio 00:11:28
Le pongo una S delante 00:11:31
Entonces si me habéis puesto 00:11:33
El número 3 00:11:34
Ahora mi código 00:11:35
El código de este servicio 00:11:37
No es 3 00:11:38
Es S3 00:11:38
¿Sí? 00:11:40
De esta forma 00:11:43
En un cierto sentido 00:11:44
El código tendrá delante 00:11:45
Una letra 00:11:46
Que me hace 00:11:47
Saber 00:11:49
Si es un servicio 00:11:50
Si es un 00:11:51
Material 00:11:52
Si es un 00:11:54
Lo que sea 00:11:55
¿Sí? 00:11:56
Vale 00:11:58
Coste 00:12:01
¿Cómo se calcula el coste? 00:12:02
¿Vale? 00:12:04
De este servicio 00:12:04
Pues 00:12:06
Este coste 00:12:06
Será calculado como 00:12:07
Dis.precio 00:12:09
Multiplicado 00:12:12
Dis.tiempo 00:12:14
¿Vale? 00:12:16
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:17
¿Vale? 00:12:20
¿Sí? 00:12:21
¿Dudas? 00:12:22
Vale 00:12:32
Esta la hemos hecho 00:12:32
Servicio 00:12:36
Vamos a crear 00:12:37
Una nueva 00:12:38
Clase 00:12:39
¿Vale? 00:12:41
Siempre en nuestra jerarquía 00:12:41
De productos 00:12:43
Y cosas por el estilo 00:12:43
Que sería para mí 00:12:44
El servicio 00:12:46
Premium 00:12:47
Servicio Premium 00:12:48
Que extende que 00:12:49
Servicio en este caso 00:12:50
¿Vale? 00:12:51
Estoy siguiendo la jerarquía 00:12:51
¿Bien? 00:12:53
Entonces 00:12:53
Servicio Premium 00:12:54
Que tendrá 00:12:54
Será parecida a esto 00:12:55
Como 00:12:56
Constructor 00:12:56
¿Vale? 00:12:58
¿Vale? 00:12:59
Como 00:13:00
En este caso 00:13:02
Tiene la jerarquía 00:13:03
¿Bien? 00:13:05
Entonces 00:13:05
Servicio Premium 00:13:08
Que tendrá 00:13:09
Será parecido a esto 00:13:10
Como 00:13:11
Constructor 00:13:12
¿Vale? 00:13:13
Esa 00:13:14
Esa es la jerarquía 00:13:15
¿Vale? 00:13:16
Esa es la jerarquía 00:13:16
Pillará nombre, precio, descripción y tiempo 00:13:17
Y llamará 00:13:22
El super constructor 00:13:25
El constructor de la clase de arriba 00:13:28
Con estos cuatro parámetros 00:13:30
Porque os recuerdo que el servicio pilla cuatro parámetros 00:13:31
Y después 00:13:33
Tendrá que hacer lo que hace falta 00:13:38
Para completar 00:13:43
Lo que es un servicio premium 00:13:45
Tened en cuenta también que esto se llama servicio premium 00:13:48
¿Qué tiene de especial servicio premium con respecto a servicio? 00:13:51
Pues me lo invento 00:14:00
Que tiene unas llamadas urgentes 00:14:00
Int llamadas urgentes 00:14:03
Estas llamadas urgentes 00:14:07
Son prácticamente una serie de llamadas 00:14:10
Que tú contratas con este servicio premium 00:14:13
Y cuando 00:14:15
Te juegas una llamada urgente 00:14:15
Pues entonces vienen más rápidos 00:14:18
¿Vale? Pero pues esto cuesta más 00:14:19
¿Sí? 00:14:21
Entonces a cuando me crea un servicio premium 00:14:23
Tendré que darle también un int 00:14:25
Eh... 00:14:28
Llamadas 00:14:30
Y decir que 00:14:30
Llamadas 00:14:33
Urgentes 00:14:37
, es igual a llamadas 00:14:45
Es igual a llamadas 00:14:52
¿Sí? 00:14:53
Ahora 00:14:54
Coste 00:14:55
Está ya definido 00:14:58
¿Vale? 00:15:01
Está 00:15:03
No necesito implementarlo otra vez 00:15:03
Porque 00:15:06
Producto era abstracto 00:15:07
En servicio se ha implementado 00:15:10
Y servicio premium 00:15:12
Está importando el servicio premium 00:15:14
Está importando el servicio premium 00:15:15
Está importando el servicio premium 00:15:15
Está importando el servicio premium 00:15:15
Está importando ese servicio 00:15:15
Ese método 00:15:16
Si este cálculo del coste 00:15:18
Me vale 00:15:22
No necesito 00:15:22
Volver a escribirlo 00:15:24
¿Vale? 00:15:28
Pero hagamos que 00:15:28
El cálculo del coste de un servicio premium sea distinto 00:15:30
¿Vale? 00:15:33
¿Cómo calculo el coste 00:15:35
De un servicio premium? 00:15:38
Que además del tiempo 00:15:39
Que tú lo has pillado 00:15:41
¿Vale? 00:15:43
¿Vale? 00:15:44
Más 00:15:45
Llamadas urgentes 00:15:46
Multiplicado 00:15:55
100 euros por cada multiplicado 00:15:59
Que se yo 00:16:07
Un momento ¿Vale? 00:16:08
Entonces 00:16:11
Es la idea de que 00:16:12
El coste del servicio premium 00:16:13
Es distinto a la de un servicio premium 00:16:15
Es distinto 00:16:15
Se calcula de una forma distinta 00:16:16
¿Por qué me sirve esto? 00:16:18
Para luego trabajar con el polimorfismo 00:16:20
¿Vale? 00:16:23
Para ver que si yo llamo coste 00:16:24
Sobre un objeto 00:16:26
De tipo 00:16:28
O sea 00:16:29
Que como instancia es un servicio premium 00:16:29
Me hará esto 00:16:31
Si yo lo llamo sobre un 00:16:33
Servicio normal 00:16:35
Me hará esto 00:16:37
¿Sí? 00:16:38
¿Dudas hasta aquí? 00:16:41
Sí 00:16:43
¿Vale? 00:16:44
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
¿Vale? 00:16:45
No, porque el precio es el precio del servicio 00:16:53
El precio del servicio es el mismo 00:16:56
Yo tengo mantenimiento 00:16:59
Mantenimiento son 50 euros al mes 00:17:01
¿Vale? 00:17:03
Y allí en precio pongo 50 00:17:04
Y tú lo puedes contratar como servicio normal 00:17:05
Entonces será 50 por los meses que tú 00:17:08
O además de los 50 00:17:10
Y a contratar un cierto número de servicios 00:17:13
Un número de llamadas urgentes 00:17:15
Entonces te costará 50 euros por los 6 meses 00:17:17
Más 100 euros por cada una llamada urgente 00:17:21
Que quieres tener en tu producto 00:17:24
Es absurdo, pero 00:17:27
Claro, el coste al final 00:17:29
Lo que dices tú del precio 00:17:37
Es el coste 00:17:39
El precio es el precio unitario 00:17:41
El coste es 00:17:42
Cuánto me viene a costar 00:17:43
Lo que tú has efectivamente 00:17:45
Que depende de 00:17:47
Cuánto tiempo 00:17:49
Y depende de cuántas horas 00:17:51
¿Vale? 00:17:53
Aquí ya había metido también un método de 00:17:54
Extender meses 00:17:56
O hacer cosas 00:17:58
Pero es que tiene 00:18:00
Tiene relativamente poco sentido 00:18:01
Para el cálculo del coste 00:18:02
Por lo tanto los dejamos fuera 00:18:03
¿Vale? 00:18:05
Tanto con esto 00:18:05
Ya algo hacemos 00:18:06
¿Sí? 00:18:07
También 00:18:09
Eh... 00:18:09
Bip, bip, bip, bip 00:18:13
Vamos a 00:18:14
Crear un nuevo 00:18:15
Clase 00:18:16
Que es para cosas 00:18:21
Que no son servicios 00:18:23
Son cosas material 00:18:24
Yo lo he llamado material 00:18:25
Pero bueno 00:18:26
Sería servicio 00:18:27
Sería producto físico 00:18:29
Sería... 00:18:31
¿Cómo queréis llamarlo? 00:18:32
Material 00:18:34
El material 00:18:34
Que yo pueda comprar 00:18:39
Tiene como característica 00:18:42
Que tiene un coste de envío 00:18:43
¿Vale? 00:18:45
Vale 00:18:45
Porque mientras los servicios 00:18:47
No tienen coste de envío 00:18:51
Porque tú contratas 00:18:52
El interés del servicio 00:18:53
Y ya lo tienes 00:18:54
Pues un material 00:18:54
Para mandártelo a tu casa 00:18:56
Pues necesito 00:18:57
Para pagar 00:18:58
Algo de envío 00:18:59
¿Sí? 00:19:00
Y entonces 00:19:00
Ah, perdón 00:19:01
Eh... 00:19:04
Material 00:19:04
Extende 00:19:05
¿Quién extiende material? 00:19:06
Producto 00:19:08
Porque no es un servicio 00:19:09
¿Vale? 00:19:12
Public 00:19:14
Material 00:19:15
Que pillará 00:19:16
Todas estas cosas de aquí 00:19:19
¿Vale? 00:19:22
¿Vale? 00:19:22
Pillará nombre, precio, descripción 00:19:32
Tiempo, ¿no? 00:19:35
Y llamará 00:19:39
Super 00:19:40
Nombre, precio, descripción 00:19:41
O sea, el super 00:19:43
El... 00:19:45
Este super 00:19:45
Es el constructor 00:19:46
¿De quién? 00:19:47
¿De qué clase? 00:19:49
De producto 00:19:51
¿Vale? 00:19:52
Y el constructor de producto 00:19:52
Pillaba estos tres parámetros 00:19:53
¿Sí? 00:19:54
Además 00:19:56
Aquí tendré que ponerle 00:19:57
Cuánto costa el envío 00:19:58
¿Sí? 00:19:59
Y tendré que hacer 00:20:04
Que dis.envío 00:20:05
Es igual a envío 00:20:07
Y ahora 00:20:09
Cuando sobre escribo el coste 00:20:11
O sea, cuando 00:20:12
Fijaos que ahora se enfada 00:20:13
¿Por qué se enfada? 00:20:15
¿Por qué? 00:20:18
¿Por qué? 00:20:20
El método es abstracto 00:20:22
Y no lo ha implementado 00:20:24
¿Vale? 00:20:25
Aquí no se enfadaba 00:20:27
Porque yo extendiendo servicio 00:20:29
Ya el método estaba implementado 00:20:30
Pero ahora estoy volviendo 00:20:32
A extender una clase abstracta 00:20:34
Que es la clase producto 00:20:36
Entonces me está diciendo 00:20:37
Oye, mira, que te falta 00:20:39
El método abstracto este de aquí 00:20:40
Que tienes que implementar tú 00:20:42
¿Vale? 00:20:44
¿Vale? 00:20:46
Entonces yo me voy aquí 00:20:46
Y me lo implemento 00:20:48
Y digo que esto es 00:20:54
Return 00:20:56
Dis.precio 00:20:57
Más 00:21:06
Dis.envío 00:21:08
, ¿por qué? 00:21:15
¿Por qué no? 00:21:16
Pues esto es�� 00:21:17
¿Por qué? 00:21:26
¿Por qué? 00:21:27
Entonces aquí se entiende 00:21:28
Que material es un objeto concreto 00:21:30
Es un producto concreto 00:21:32
¿Vale? 00:21:33
Compro un ordenador 00:21:33
Si compro 10 ordenadores 00:21:34
No es que puedo poner aquí 00:21:36
10 por esto 00:21:37
No, tengo que comprar 10 productos ordenados 00:21:38
¿Sí? 00:21:40
Es absurdo 00:21:41
Así no es como se haría 00:21:42
En una... 00:21:44
En un pedido real tú dices 00:21:45
Quiero este producto por 10 00:21:46
Pero aquí lo hacemos así para simplificar 00:21:48
Dudas 00:21:51
Entonces con esto he creado 00:21:53
Mi estructura 00:21:55
¿Vale? 00:21:58
Mi estructura tiene 00:22:03
Producto 00:22:04
Tiene servicio 00:22:06
Que hereda de producto 00:22:11
Tiene servicio premium 00:22:14
Que hereda de servicio 00:22:18
Y tiene 00:22:23
Material 00:22:24
Que hereda de producto 00:22:26
Esto es lo que he hecho más o menos 00:22:29
Se me ha olvidado algo 00:22:31
Que habíamos empezado bien con esto 00:22:33
Pero ahora lo tenemos que hacer también los otros 00:22:35
En particular 00:22:39
Si soy un material 00:22:43
Quiero poner una M 00:22:44
Y que si soy un servicio premium 00:22:47
Le pego delante 00:22:55
Una P 00:22:58
Vendría premium service 00:22:59
¿Vale? 00:23:02
Y con esto más o menos 00:23:08
Tengo 00:23:11
Creada la parte de los productos 00:23:14
¿Vale? 00:23:17
Cuando llamo esto 00:23:29
Yo tenía un numerito 00:23:32
Esto es este de aquí 00:23:34
Que llama esto 00:23:36
Por lo tanto esto mete un número 00:23:37
¿Vale? 00:23:40
Le pega delante una S 00:23:40
Se vuelve S3 00:23:42
Y luego llega aquí 00:23:44
Y lo que hace es meterle una P delante 00:23:46
Premium service 00:23:48
No servicio premium 00:23:49
O sea, si lo quisiera poner detrás 00:23:53
Pues eso es complicado 00:23:56
Debería buscar 00:23:57
Quitar la primera 00:23:59
Meter la cosa 00:24:00
Se podría hacer 00:24:01
Pero no quiero perder tiempo ahí 00:24:02
¿Vale? 00:24:04
Lo importante es que tenga una cosa distinta 00:24:04
Técnicamente yo 00:24:06
El código son todos distintos 00:24:08
No puede haber dos códigos iguales 00:24:09
Porque todo depende del producto 00:24:11
Todos llegan al producto 00:24:13
Entonces los números siempre cambiarán 00:24:14
Siempre serán productos distintos 00:24:16
Lo único es que si quiero saber 00:24:17
Si es un servicio premium 00:24:19
Un servicio o un cosa 00:24:21
A través de su código 00:24:23
La única cosa que tengo que mirar 00:24:25
Es la primera letra 00:24:26
PSOM 00:24:27
¿Sí? 00:24:28
Vale 00:24:31
Entonces 00:24:32
Ahora lo que vamos a hacer 00:24:34
Es crear otra 00:24:36
Clase 00:24:37
Que manipula 00:24:40
Que maneja 00:24:41
Algunos productos 00:24:42
¿Vale? 00:24:43
Vamos a crear un tipo de 00:24:44
De entidad 00:24:45
De mi 00:24:46
De mi programa 00:24:47
Que es la clase 00:24:48
Usuario 00:24:49
¿Vale? 00:24:50
O cliente 00:24:51
O lo que sea 00:24:52
Y luego después 00:24:53
Vamos a hacer una clase 00:24:54
Main 00:24:55
Que es la que 00:24:56
Relaciona estas cosas 00:24:57
¿Sí? 00:24:58
Entonces vamos a pillar 00:24:59
Un usuario 00:25:00
Vamos a hacer 00:25:01
Un usuario 00:25:02
Un usuario 00:25:03
Un usuario 00:25:04
Un usuario 00:25:05
Un usuario 00:25:06
Un usuario 00:25:07
Un usuario 00:25:08
Un usuario 00:25:09
Un usuario 00:25:10
Un usuario 00:25:11
Un usuario 00:25:12
Un usuario 00:25:13
Un usuario 00:25:14
Un usuario 00:25:15
Un usuario 00:25:16
Un usuario 00:25:17
Un usuario 00:25:18
Un usuario 00:25:19
Un usuario 00:25:20
Un usuario 00:25:21
Un usuario 00:25:22
Un usuario 00:25:23
Un usuario 00:25:24
Un usuario 00:25:25
Un usuario 00:25:26
Un usuario 00:25:27
Un usuario 00:25:28
Un usuario 00:25:29
Un usuario 00:25:30
Un usuario 00:25:31
Un usuario 00:25:32
Un usuario 00:25:33
Un usuario 00:25:34
Un usuario 00:25:35
Un usuario 00:25:36
Un usuario 00:25:37
Un usuario 00:25:38
Un usuario 00:25:39
Un usuario 00:25:40
Un usuario 00:25:41
Un usuario 00:25:42
Un usuario 00:25:43
Un usuario 00:25:44
Un usuario 00:25:45
Un usuario 00:25:46
Un usuario 00:25:47
Un usuario 00:25:48
Un usuario 00:25:49
Un usuario 00:25:50
Un usuario 00:25:51
Un usuario 00:25:52
Un usuario 00:25:53
Un usuario 00:25:54
Un usuario 00:25:55
Un usuario 00:25:56
Un usuario 00:25:57
Un usuario 00:25:58
Un usuario 00:25:59
Un usuario 00:26:00
Un usuario 00:26:01
Un usuario 00:26:02
Un usuario 00:26:03
Un usuario 00:26:04
Un usuario 00:26:05
Un usuario 00:26:06
Un usuario 00:26:07
Un usuario 00:26:08
Un usuario 00:26:09
Un usuario 00:26:10
Un usuario 00:26:11
Un usuario 00:26:12
Un usuario 00:26:13
Un usuario 00:26:14
Un usuario 00:26:15
Un usuario 00:26:16
Un usuario 00:26:17
Un usuario 00:26:18
Un usuario 00:26:19
Un usuario 00:26:20
Un usuario 00:26:21
Un usuario 00:26:22
Un usuario 00:26:23
Un usuario 00:26:24
Un usuario 00:26:25
Un usuario 00:26:26
Un usuario 00:26:27
Un usuario 00:26:28
Un usuario 00:26:29
Un usuario 00:26:30
Un usuario 00:26:31
Un usuario 00:26:32
Un usuario 00:26:33
Un usuario 00:26:34
Un usuario 00:26:35
Un usuario 00:26:36
Un usuario 00:26:37
Un usuario 00:26:38
Un usuario 00:26:39
Un usuario 00:26:40
Un usuario 00:26:41
Un usuario 00:26:42
Un usuario 00:26:43
Un usuario 00:26:44
Un usuario 00:26:45
Un usuario 00:26:46
Un usuario 00:26:47
Un usuario 00:26:48
Un usuario 00:26:49
Un usuario 00:26:50
Un usuario 00:26:51
Un usuario 00:26:52
Un usuario 00:26:53
Un usuario 00:26:54
Un usuario 00:26:55
Un usuario 00:26:56
Un usuario 00:26:57
Un usuario 00:26:58
Un usuario 00:26:59
Un usuario 00:27:00
Un usuario 00:27:01
Un usuario 00:27:02
Un usuario 00:27:03
Un usuario 00:27:04
Un usuario 00:27:05
Un usuario 00:27:06
Un usuario 00:27:07
Un usuario 00:27:08
Un usuario 00:27:09
Un usuario 00:27:10
Un usuario 00:27:11
Un usuario 00:27:12
Un usuario 00:27:13
Un usuario 00:27:14
Un usuario 00:27:15
Un usuario 00:27:16
Un usuario 00:27:17
Un usuario 00:27:18
Un usuario 00:27:19
Un usuario 00:27:20
Un usuario 00:27:21
Un usuario 00:27:22
Un usuario 00:27:23
Un usuario 00:27:24
Un usuario 00:27:25
Un usuario 00:27:26
Un usuario 00:27:27
Un usuario 00:27:28
Un usuario 00:27:29
Un usuario 00:27:30
Un usuario 00:27:31
Un usuario 00:27:32
Un usuario 00:27:33
Un usuario 00:27:34
Un usuario 00:27:35
Un usuario 00:27:36
Un usuario 00:27:37
Un usuario 00:27:38
Un usuario 00:27:39
Un usuario 00:27:40
Un usuario 00:27:41
Un usuario 00:27:42
Un usuario 00:27:43
Un usuario 00:27:44
Un usuario 00:27:45
Un usuario 00:27:46
Un usuario 00:27:47
Un usuario 00:27:48
Un usuario 00:27:49
Un usuario 00:27:50
Un usuario 00:27:51
Un usuario 00:27:52
Un usuario 00:27:53
Un usuario 00:27:54
Un usuario 00:27:55
Un usuario 00:27:56
Un usuario 00:27:57
Un usuario 00:27:58
Un usuario 00:27:59
Un usuario 00:28:00
Un usuario 00:28:01
Un usuario 00:28:02
Un usuario 00:28:03
Un usuario 00:28:04
Un usuario 00:28:05
Un usuario 00:28:06
Un usuario 00:28:07
Un usuario 00:28:08
Un usuario 00:28:09
Un usuario 00:28:10
Un usuario 00:28:11
Un usuario 00:28:12
Un usuario 00:28:13
Un usuario 00:28:14
Un usuario 00:28:15
Un usuario 00:28:16
Un usuario 00:28:17
Un usuario 00:28:18
Un usuario 00:28:19
Un usuario 00:28:20
Un usuario 00:28:21
Un usuario 00:28:22
Un usuario 00:28:23
Un usuario 00:28:24
Un usuario 00:28:25
Un usuario 00:28:26
Un usuario 00:28:27
Un usuario 00:28:28
Un usuario 00:28:29
Un usuario 00:28:30
Un usuario 00:28:31
Un usuario 00:28:32
Un usuario 00:28:33
Un usuario 00:28:34
Un usuario 00:28:35
Un usuario 00:28:36
Un usuario 00:28:37
si, pero no quiero usar premio otra vez porque luego me viene la pena 00:28:38
cliente 00:28:43
gold 00:28:45
claramente 00:28:47
que extiende 00:28:48
cliente 00:28:52
que tiene 00:28:56
prácticamente 00:29:02
esto 00:29:04
cliente gold 00:29:07
super 00:29:17
nombre 00:29:20
esto tiene claramente un int 00:29:22
descuento 00:29:27
coma int 00:29:28
descuento 00:29:33
distruto 00:29:34
punto descuento 00:29:37
es igual al descuento 00:29:38
vale, luego vamos a ver si lo usamos 00:29:40
para algo, la idea sería que 00:29:43
si eres un cliente 00:29:45
gold, pues lo que estás haciendo 00:29:46
es que tienes derecho a un descuento 00:29:49
sobre las cosas, entonces 00:29:51
ya veremos 00:29:53
para que nos sirve todo esto 00:29:54
vale 00:29:56
esto es 00:29:58
un poquito de repaso, un poquito de idea 00:30:00
de como se crean 00:30:03
herencia, constructor 00:30:05
el super 00:30:07
la sobre escritura de métodos 00:30:08
etc, etc, etc 00:30:10
vamos ahora a aplicarlo 00:30:11
vale, es donde vemos más 00:30:14
como funciona el polimorfismo 00:30:15
y como podemos 00:30:17
utilizarlo, vale 00:30:18
entonces creamos una clase main 00:30:21
que será nuestro sistema 00:30:23
lo llamo sistema 00:30:25
sistema 00:30:27
que tiene el main 00:30:28
vale, entonces 00:30:30
este sistema lo que 00:30:33
debería hacer es 00:30:35
me permite trabajar 00:30:36
con la gente, vale, trabajar con 00:30:38
estos sistemas 00:30:41
para poder trabajar con este sistema 00:30:42
y luego lo complicamos cuanto nos da la gana 00:30:45
voy a crear 00:30:47
algunas cosillas creadas así 00:30:48
para poder trabajar 00:30:51
vale, y luego a partir de allí 00:30:53
vemos como 00:30:55
como lo trabajamos 00:30:56
como lo extendemos, vale 00:30:59
entonces me voy a crear un par de usuarios 00:31:00
cliente 00:31:03
es igual a new cliente 00:31:08
que se llama 00:31:12
cliente 0 00:31:14
cliente 00:31:16
c1 es igual a 00:31:21
new cliente 00:31:23
cliente 1 00:31:25
y cliente 00:31:28
gold 00:31:32
es igual a new cliente gold 00:31:35
de cliente 00:31:39
gold 00:31:43
coma 00:31:46
10% 00:31:48
entonces esto luego lo estoy haciendo así 00:31:53
para ir rápidamente, vale 00:31:55
podría hacerme un menú 00:31:57
donde le digo, hay la opción 00:31:59
añadir usuario, entonces mi sistema me permite 00:32:01
crear un usuario nuevo donde me pregunto 00:32:03
cuál es su nombre, si es un cliente Gold 00:32:05
se les es un cliente Gold 00:32:07
tierra de su 00:32:09
eeeep 00:32:10
el descuento y cosas por el estile 00:32:12
vale 00:32:14
por ahora no lo hago 00:32:14
adelante voy 00:32:16
voy a hacer lo que me interesa de verdad 00:32:17
luego ya 00:32:20
y luego me necesito una cantidad de 00:32:22
servicios 00:32:25
vale, esto me hace distraer a los clientes 00:32:25
se los vendìsono a los clientes 00:32:27
Por ahora lo hacemos así 00:32:33
Luego lo creamos 00:32:35
¿Vale? 00:32:35
Entonces por ejemplo 00:32:36
Tengo un 00:32:37
Producto 00:32:38
¿Si? 00:32:40
Producto X 00:32:41
Que es igual a new producto 00:32:42
¿Qué parámetros pillaba? 00:32:44
El nombre 00:32:48
Así 00:32:49
Esto es un 00:32:51
Ordenador 00:32:53
Coma 00:32:54
¿Qué más? 00:32:56
Código 00:33:00
Que pero se lo crea el solo 00:33:00
El precio 00:33:01
Precio son 00:33:03
Mil euros 00:33:04
Y ya está 00:33:06
Es descripción 00:33:07
Un ordenador 00:33:09
Muy bonito 00:33:13
Perfecto 00:33:14
¿Por qué se enfada? 00:33:18
¿Y por qué nadie me ha parado? 00:33:21
Porque producto es abstracto 00:33:25
No puedo crear un producto 00:33:28
El hecho que producto 00:33:31
Sea abstract 00:33:34
Impide que se pueda hacer 00:33:37
Una instancia de producto 00:33:39
¿Por qué no se puede hacer 00:33:41
Una instancia de producto? 00:33:42
Porque es abstracto 00:33:44
¿Por qué no se puede hacer 00:33:45
Una instancia de producto? 00:33:46
Porque si yo creara un producto 00:33:53
Cuando luego uso este método de aquí 00:33:56
Él no sabe qué hacer 00:33:58
Porque este método de aquí 00:34:01
No sabe qué hacer 00:34:01
No tiene un cuerpo 00:34:01
No se sabe 00:34:02
Qué debería hacer 00:34:04
Es un método abstracto 00:34:05
Es un método que no se puede utilizar 00:34:07
En un objeto concreto 00:34:08
Es una generalización 00:34:09
Es un contrato 00:34:12
Es una idea 00:34:14
De cómo tiene que ser un producto 00:34:15
Pero no puede nunca ser un producto real 00:34:17
Entonces no puedo crear un producto 00:34:19
Pero si lo que puedo crear 00:34:22
Es por ejemplo un material 00:34:25
Que es un ordenador 00:34:31
Que cuesta mil 00:34:33
Es un ordenador muy bonito 00:34:36
Y cuesta por envío 00:34:38
Trece euros 00:34:40
Ahora sí 00:34:42
Luego por ejemplo 00:34:45
Creo un servicio 00:34:53
Servicio 00:34:55
No entiendo 00:35:01
No entiendo 00:35:13
Sí, un segundo solo 00:35:13
Servicio S1 00:35:16
Pues un servicio 00:35:20
Valores 00:35:23
No me acuerdo qué era 00:35:26
Era siempre nombre 00:35:27
Esto es 00:35:28
Entendimiento 00:35:30
Coma 00:35:31
¿Cuánto cuesta al mes el mantenimiento? 00:35:36
Claramente 00:35:39
Cento cinco 00:35:39
Cento euros 00:35:40
Coma 00:35:41
Resolvemos 00:35:44
Todos tus problemas 00:35:48
Coma 00:35:50
¿Cuánto tiempo? 00:35:56
Vale 00:35:58
Pongamos que esto es 00:35:59
El paquete de seis meses 00:36:00
Vale 00:36:01
Luego está 00:36:01
Hagamos otro servicio 00:36:04
Servicio de actualización 00:36:07
Actualización 00:36:11
Que son diez 00:36:14
Euros 00:36:16
Actualizamos tu software 00:36:19
Y por un mes 00:36:24
Y por un mes 00:36:30
Actualizamos tu software 00:36:30
Actualizamos tu software 00:36:30
Actualizamos tu software 00:36:30
Actualizamos tu software 00:36:30
Y servicio Premium 00:36:31
Actualizamos mi site 00:36:33
Y comencemos 00:36:33
Aquí 00:36:33
Y servicio Premium 00:36:34
Chicos 00:36:40
Hola 00:36:42
Jago 00:36:44
오라 00:36:45
Servicio Premium 00:36:47
Servicio Premium 00:36:49
Eeeee 00:36:52
Que soy yo 00:36:53
Mantenimiento Plus 00:36:56
Que costa более de cien euros 00:37:00
Que parte siempre 100 euros 00:37:01
Pero resolvemos 00:37:01
Todo y más 00:37:05
Por 00:37:06
Tres meses 00:37:09
Con diez llamadas de urgentas 00:37:11
Incluidas 00:37:14
¿Sí? 00:37:16
Vale, entonces 00:37:19
Todo esto 00:37:20
Es para hacer pruebas 00:37:22
En realidad esto no se debería poner aquí 00:37:24
Aquí debería haber un interfaz 00:37:26
De algún tipo que te dice 00:37:28
Añade un utente 00:37:30
Vale, sí, crea un nuevo servicio 00:37:31
Vale, crea un nuevo servicio 00:37:34
¿Qué parámetros me das? 00:37:35
Y crea el nuevo servicio 00:37:37
Luego a lo mejor este servicio lo venda el utente 00:37:38
¿Me entendéis lo que quiero decir? 00:37:40
Pero lo quiero hacer un poquito más rápido 00:37:43
Por lo tanto me creo estas cosas de aquí 00:37:45
Y ahora las asigno a los clientes de alguna forma 00:37:47
¿Sí? 00:37:49
¿Sí? 00:37:51
Pensando en eso para ejercir 00:37:52
Para eso tendría que ser 00:37:54
Menos que 00:37:57
Luego los servicios 00:37:57
Que no lo hace 00:38:00
¿Sí? 00:38:01
Sobre los productos 00:38:01
Es esto 00:38:03
Ahora lo vamos a hacer 00:38:06
¿Vale? 00:38:10
Entonces, ahora mi sistema 00:38:11
Imaginaos que de un lado tiene 00:38:13
Un fichero 00:38:16
De donde carga todos los clientes 00:38:17
Y de otro lado tiene un fichero 00:38:21
Inventarios de donde calcula 00:38:22
Donde saca 00:38:25
Todos los materiales 00:38:26
Y servicios que puede vender 00:38:28
¿Vale? 00:38:31
¿Qué son estos? 00:38:33
Hagamos otro material 00:38:33
Por otra cosa 00:38:35
Por jugar con ello 00:38:36
¿Vale? 00:38:38
Es un portátil 00:38:39
De 2000 euros 00:38:40
Un portátil 00:38:43
Muy bonito 00:38:48
Y esto no me acuerdo que era 00:38:50
Este 13 que era 00:38:52
No me seguís 00:38:55
Le envío 00:39:00
¿Cuánto costa el envío? 00:39:01
Señores, me perdí 00:39:02
Esto costa 10 euros 00:39:03
Porque pesa menos 00:39:06
¿Vale? 00:39:08
Entonces 00:39:09
Asumamos que esto lo haya hecho 00:39:10
De alguna forma 00:39:12
¿Vale? 00:39:13
Repito que 00:39:14
Podría ser que tú lo hagas 00:39:14
Manualmente 00:39:16
Cosas así 00:39:17
No lo quiero hacer manualmente 00:39:17
Porque si no cada vez que hago un ejemplo 00:39:18
Tengo que volver a recrearme 00:39:20
Todas estas cosas 00:39:22
¿Vale? 00:39:23
Entonces me las he creado yo 00:39:23
Directamente 00:39:25
Esto lo más obvio 00:39:26
Repito 00:39:27
Sería que 00:39:28
Esta información 00:39:29
Esta información 00:39:31
La saque de algún lado 00:39:31
De una base de datos 00:39:33
De un fichero 00:39:35
Como nosotros no sabemos usar 00:39:37
Ni base de datos 00:39:39
Ni ficheros 00:39:40
¿Os acordáis el ejercicio eso? 00:39:40
Donde os daba una cadena 00:39:43
Separada por punto y coma 00:39:44
Y comas 00:39:47
Y de allí creabais 00:39:48
No me acuerdo que tipo de objeto 00:39:49
Pues eso podría ser 00:39:51
Como lo usamos nosotros 00:39:52
Nosotros nos dan un parámetro 00:39:53
Donde ponen 00:39:55
Cliente 0 00:39:56
Cliente 1 00:39:57
O sea cliente 0 punto y coma 00:39:58
Cliente 1 punto y coma 00:39:59
Cliente 2 punto y coma 00:40:00
Cliente 2 punto y coma 00:40:01
Y en base a eso 00:40:03
Yo me creé los 00:40:03
Los objetos que quiero 00:40:04
Lo veremos a lo mejor 00:40:06
Si tenemos más tiempo más adelante 00:40:07
Por ahora centramos 00:40:09
Solo que 00:40:10
Estos son los objetos 00:40:11
Con que voy a utilizar 00:40:12
¿Vale? 00:40:14
Entonces 00:40:15
¿Qué quiero hacer ahora? 00:40:16
Yo quiero 00:40:17
Y esto si que ya empiezo a hacerlo 00:40:18
Poder 00:40:20
Seleccionar un cliente 00:40:21
Y decirle 00:40:23
Oye mira 00:40:24
Este cliente 00:40:25
Asociale uno de los productos 00:40:26
Que tú tienes 00:40:28
¿Si? 00:40:29
Entonces 00:40:31
¿Cómo voy a hacer 00:40:32
Eso? 00:40:33
Primera cosa 00:40:35
A lo mejor dentro de cliente 00:40:37
Me gustaría 00:40:38
Tener un 00:40:39
Un método 00:40:40
Que yo te doy un producto 00:40:42
Y tú lo añades a tus productos 00:40:43
¿Vale? 00:40:45
Entonces creámoslo 00:40:46
Public 00:40:48
Bolean 00:40:54
Inserta 00:40:55
Producto 00:40:59
¿Qué pilla este 00:41:01
Este inserta producto? 00:41:03
Servicio 00:41:07
Material 00:41:08
¿Qué pilla? 00:41:08
Un producto 00:41:14
¿Qué es este? 00:41:30
O bueno 00:41:31
¡Eh! 00:41:33
¡Oh! 00:41:37
No se como decirlo 00:41:37
Representaría 00:41:39
Si se ha podido insertar 00:41:40
¿Vale? 00:41:42
Entonces insertar 00:41:43
La idea es, si hay algún problema 00:41:50
Allí no se puede insertar este producto 00:41:52
Pues que al final me diga falso 00:41:54
En el momento en que lo puedo insertar 00:41:55
Pues me diga tuvo 00:41:57
¿Si? 00:41:58
Ehh 00:41:59
¿Me sirve de algo? 00:42:00
No, probablemente no, pero en casos más avanzados, cuando veremos las excepciones, que podría explotar algo aquí dentro, 00:42:01
pues me podría servir de, oye, mira, he intentado hacerlo, pero no lo he conseguido, entonces te digo falso, ¿sí? 00:42:08
Entonces, ahora tengo que poner un nuevo producto, hemos asumido que esto está siempre, no hay null, no hay zonas null en mi producto, ¿vale? 00:42:13
Por lo tanto, lo que voy a hacer es asumir que mi producto ya está lleno, y tengo que añadirle un hueco al final, para poder añadir un nuevo producto, ¿vale? 00:42:24
Lo de siempre, for, bueno, producto, p es igual, nuevo productos, es igual a new productos, 00:42:35
de productos.length, más uno. 00:42:54
Puedo hacer una pregunta, no hay calor aquí, ¿podéis abrir un par de ventanas, o os mata? 00:43:06
Para regular. 00:43:17
Si la abres, bueno, si no, dejadla así, es solo que, vale, entonces, este nuevo producto, es un array de productos un poquito más grande del que tenía antes, 00:43:24
si antes tenía tres productos, ahora tengo cuatro, ¿sí? 00:43:48
Voy a... 00:43:52
for int i es igual a cero, i menor que productos.length, i más más, 00:43:54
nuevo productos de i es igual a productos de i, estoy copiando productos de i dentro de nuevo productos, ¿sí? 00:44:03
Al final de todo esto, productos, es igual a nuevo productos, esto ya lo hemos hecho quince veces, ¿vale? 00:44:24
Siempre lo mismo, de esta forma, ahora, en productos, en la última posición de productos, pues, tengo una posición libre, entonces, puedo decir que, 00:44:40
productos de productos.length, menos uno, es igual a p, y entonces, insertado, es igual a true, tiene poco sentido, 00:44:54
esto tendría sentido si aquí hubiese un if, o si lo puedo hacer, entonces, hazlo, no, pero bueno, mira, sí, entonces, 00:45:13
ahora, yo tengo ya un método para insertar productos, dentro de este de aquí, vale, fenomenal, entonces, ahora, yo aquí, 00:45:23
lo que voy a hacer, es, un, leer, por ejemplo, a qué cliente quiero insertar el, el producto, y, qué producto insertar, ¿vale? 00:45:34
Entonces, probamos así. 00:45:47
Voy a, empezamos con, voy a describir todos los clientes que tengo, ¿vale? 00:45:53
Es decir, cuando yo empiezo el sistema, me dice, estos son tus clientes, ¿a qué clientes quieres añadir algo? 00:46:09
¿Sí? 00:46:17
Entonces, empezamos que lo haga una vez, luego, después, lo ponemos en un while, 00:46:18
y luego, lo hacemos muchas veces, ¿sí? 00:46:23
Quiero leer cosas, entonces, scanner, scan, es igual a new scanner, de system.in, 00:46:26
scanner es este de aquí, vale, ok, ahora, yo quiero aquí, poner una descripción, 00:46:41
de cada cliente, ¿vale? 00:46:53
Con su código, sustancialmente, sería, si eso, elige, el código, cliente, dos puntos, pero, antes, de esta cosa aquí, aquí dentro, aquí, 00:46:57
quiero que me ponga, todos los códigos clientes posibles, de estos clientes de aquí, ¿se entiende? 00:47:15
¿Se entiende lo que quiero decir? 00:47:23
¿Cómo lo hago? 00:47:25
Sí, eso, vamos por parte, me voy a cliente, y me creo un toString, porque así no tengo que hacer, complicarme, después, ¿vale? 00:47:30
public string toString 00:47:41
y mi toString es return 00:47:44
return 00:47:50
nombre 00:47:50
más 00:47:54
dos puntos 00:47:58
más 00:48:00
código 00:48:02
va, perfecto, de esta forma, ahora, puedo escribir, directamente, un cliente, y me escribirá esta cosa aquí, ¿vale? 00:48:04
por ejemplo, podría hacer, si eso, 00:48:19
y, c2 00:48:26
¿Sí? 00:48:41
Vamos a ver, ¿qué hace esto? 00:48:43
Esto me pondría, esta cosa aquí, cliente 0, tiene este código, el cliente 1, tiene este código, el cliente 2, tiene este código, 00:48:47
elige el código cliente 00:48:53
os gusta 00:48:56
señores yo entiendo que haga reír pero 00:49:08
os gusta este código aquí 00:49:10
os parece que tiene sentido 00:49:16
porque no 00:49:19
bueno pero el cliente gold 00:49:23
hereda de esto 00:49:24
y es siempre un cliente 00:49:27
desde mi perspectiva me vale 00:49:30
el problema de esta cosa aquí 00:49:31
es que como lo hemos planteado 00:49:34
yo aquí tengo que hacer 00:49:36
un system.presentln por cada 00:49:38
cliente 00:49:40
y eso es feo 00:49:42
porque si ahora aquí en vez de 3 clientes te pongo 50 00:49:43
que hago? modifico el código 00:49:50
no habría una forma de hacerlo 00:49:52
un poquito más elegante 00:49:54
vale hago un for 00:49:56
dime el for 00:49:59
control espacio 00:49:59
si subo 00:50:22
este si 00:50:32
6 0 00:50:42
no pero la variable 00:50:46
la variable es la variable 0 00:50:50
no pero la variable 0 00:50:51
¿Qué quiere decir la variable? 00:50:52
C0, minúscula 00:50:55
¿Qué me falta para poder hacer esto? 00:50:56
Un array 00:51:08
No voy a hacer un for 00:51:09
Si no tengo un array 00:51:11
¿Vale? 00:51:12
Entonces en vez de poner los clientes así feo 00:51:13
Me voy a decir 00:51:17
Vale, hagamos un array de clientes 00:51:18
En mi caso son tres 00:51:21
¿Vale? 00:51:30
Entonces en vez de utilizar esto 00:51:32
¿Qué uso? 00:51:35
Clientes 00:51:42
De cero 00:51:42
Clientes 00:51:50
De u 00:51:50
Clientes de u 00:51:51
Clientes de u 00:51:51
Clientes de u 00:51:51
Clientes de u 00:51:51
A este punto si puedo hacer esta cosa aquí 00:51:55
Que por cierto no es de args 00:52:04
Si no es de clientes 00:52:06
Y por cada uno de ellos 00:52:07
Clientes 00:52:11
Clientes 00:52:13
Ahí 00:52:13
Vale 00:52:16
Y ahora ya pueden ser mil clientes 00:52:21
Y esto ya me funciona 00:52:24
¿Si? 00:52:25
Ahora, cuidado 00:52:29
¿Le veis algo raro aquí? 00:52:30
En esta parte de aquí 00:52:42
¿Le veis algo raro? 00:52:43
Algo que hasta la semana pasada no hacíamos 00:52:48
¿Qué es esto? 00:52:50
¿Qué es esto? 00:52:50
¿Qué es esto? 00:52:50
¿Qué es esto? 00:52:50
¿Qué es esto? 00:52:50
Sí, vale 00:53:00
No, pero veis que 00:53:01
¿Qué tipo tiene este cliente? 00:53:04
Es un array 00:53:09
De cliente 00:53:11
Sin embargo le estoy poniendo dentro 00:53:12
Un objeto cliente gold 00:53:15
O sea, nosotros hasta la semana pasada 00:53:17
Tipo 00:53:20
Es igual a new 00:53:23
Un tipo distinto 00:53:24
No lo hacíamos 00:53:26
O sea, hacer una cosa como 00:53:27
Cliente 00:53:30
X es igual a new cliente gold 00:53:32
De algo 00:53:37
Esto es una cosa nueva 00:53:39
¿Por qué puede hacerlo? 00:53:43
Porque cliente gold 00:53:50
Extiende cliente 00:53:52
Porque cliente gold es 00:53:54
Un cliente 00:53:56
¿Si? 00:53:58
La instancia que se pondrá aquí dentro 00:53:59
Es cliente gold 00:54:02
Pero puede ir 00:54:04
En un array de cliente 00:54:06
Porque cliente admite 00:54:08
Un cliente gold 00:54:10
Un cliente gold es un cliente 00:54:12
¿Se entiende? 00:54:14
Y esto es interesante 00:54:16
¿Si? 00:54:17
Es interesante porque me permite 00:54:19
En mi array de clientes 00:54:21
Tener 00:54:24
Tanto clientes como cliente gold 00:54:25
Sin problemas 00:54:28
Y que cuando luego lo voy a utilizar 00:54:29
Fijaos que aquí 00:54:32
Yo estoy utilizando 00:54:34
¿Qué es esto? 00:54:35
No, esto no es un array 00:54:40
Esto es un array de clientes 00:54:41
¿Esto qué es? 00:54:43
¿Qué tipo tiene esto? 00:54:46
Cliente 00:54:49
Oficialmente, formalmente 00:54:50
Esto es cliente 00:54:54
¿Si? 00:54:56
Sin embargo, cuando lo uso con este señor de aquí 00:54:57
Es un cliente gold 00:55:01
Pregunta 00:55:03
Aquí nosotros hemos hecho el toString 00:55:09
De este señor de aquí 00:55:12
¿Vale? 00:55:14
Vale 00:55:15
Si yo 00:55:15
Tengo 00:55:18
Sobre escribo 00:55:19
Cliente gold 00:55:21
O sea, tu string aquí 00:55:22
Por ejemplo 00:55:24
Marcando al final 00:55:25
Gold 00:55:27
Que este es gold 00:55:29
¿Esto se me refleja aquí o no? 00:55:30
Me explico 00:55:42
Yo aquí estoy llamando 00:55:43
Escribe 00:55:46
Declare 00:55:48
Decliente.i 00:55:49
De i 00:55:50
¿Vale? 00:55:51
Esto sería igual a hacer esto 00:55:51
Estamos haciendo esto sustancialmente 00:55:53
¿Vale? 00:55:57
Entonces estamos llamando toString 00:55:58
Sobre una referencia 00:56:00
Que es de tipo 00:56:03
Cliente 00:56:05
Entonces la pregunta es 00:56:06
¿Se usará 00:56:09
Este toString? 00:56:11
El toString de cliente 00:56:13
¿O se usará el toString de 00:56:15
Cliente gold? 00:56:17
Cliente gold 00:56:18
Siempre 00:56:19
Vamos a verlo 00:56:20
Porque os acordáis 00:56:25
¿Cómo se llama esto? 00:56:35
Polimorfismo 00:56:39
Lo que estamos estudiando ahora 00:56:39
Y yo si estoy utilizando 00:56:42
Referencias cliente 00:56:45
Aquí 00:56:47
Aquí 00:56:48
Estoy utilizando referencia cliente 00:56:49
Pero dentro puedo poner 00:56:51
Subclases de cliente 00:56:54
Como cliente gold 00:56:57
Cuando se llamará un método 00:56:58
Sobre estos objetos 00:57:00
No se mira el tipo de la referencia 00:57:02
Mas se mira el tipo de la instancia 00:57:06
Se mira sobre que he hecho el new 00:57:08
¿Si? 00:57:11
Entonces 00:57:13
Cuando esto lo llamaré sobre este aquí 00:57:14
Me usará el toString de cliente 00:57:17
Cuando lo llamaré sobre este de aquí 00:57:19
Me llamará el toString de cliente 00:57:20
Cuando lo llamaré sobre este aquí 00:57:23
No mira esto 00:57:25
Mira esto 00:57:27
Y entonces me llamará el toString de cliente gold 00:57:28
¿Si o no? 00:57:31
Importante 00:57:35
Fijaos también 00:57:35
Que si yo se lo quito 00:57:38
Entonces 00:57:40
Cuando llega aquí 00:57:44
Y lo llamo a cliente gold 00:57:46
Y lo llamo a cliente gold 00:57:48
Y lo llama sobre este objeto 00:57:49
Es verdad que esto como instancia es un cliente gold 00:57:50
Pero no tiene sobre escrito 00:57:55
El método toString 00:57:57
Dentro la clase cliente gold 00:57:59
Y entonces usará el toString 00:58:01
De su padre que es el cliente 00:58:03
Claro 00:58:08
Pero no se ha 00:58:12
Sobre escrito 00:58:16
Entonces está utilizando 00:58:16
La implementación 00:58:18
Del padre 00:58:19
Que ha heredado 00:58:19
Veo como quieres 00:58:20
Estaría utilizando esto 00:58:30
Pero porque esto 00:58:31
La herencia es como si hubiese pillado 00:58:32
Esta cosa aquí 00:58:35
Y lo hubiese escrito aquí 00:58:36
Entonces sostancialmente 00:58:37
Está usando lo del padre 00:58:40
O sea que esto del polimorfismo 00:58:41
Afecta cuando yo estoy 00:58:45
Cuando yo sobrevivo 00:58:48
El método 00:58:49
Al sobre escribir el método 00:58:50
Uso el método más específico 00:58:51
Con respecto a la instancia 00:58:54
Sin embargo 00:58:55
Si no lo he sobre escrito 00:58:58
Pues usaré 00:58:59
El de mi padre 00:58:59
O de mi abuelo 00:59:01
O el primero que lo tenga 00:59:02
Si yo lo quito de aquí 00:59:03
Que me escribe 00:59:05
He quitado el toString de aquí 00:59:09
Que me escribe el resto de aquí 00:59:15
Esto 00:59:19
¿Y qué era esto? 00:59:26
¿De dónde sale esta cosa? 00:59:30
Porque es la implementación 00:59:41
Del método toString 00:59:44
De la clase object 00:59:46
Porque mi cliente gold hereda de cliente 00:59:49
Y cliente como no hereda de nada 00:59:54
Está heredando de object 00:59:56
Y en object está el método toString 00:59:58
Que lo que dice es 01:00:03
Pilla el tipo de la instancia 01:00:04
Arroba su dirección en la memoria 01:00:07
Entonces fijaos que los primeros dos 01:00:10
Su tipo es cliente 01:00:13
Y el tercero su tipo es cliente gold 01:00:15
¿Sí? 01:00:17
Pero estoy usando 01:00:19
El toString de mi abuelo 01:00:20
En este caso 01:00:22
De mi padre aquí 01:00:23
Y de mi abuelo aquí 01:00:24
En un cierto sentido 01:00:26
¿Dudas? 01:00:27
¿Se entiende esta cosa? 01:00:29
Vuelvo a poner aquí 01:00:34
Esto 01:00:35
¿Vale? 01:00:36
Entonces esto me sirve 01:00:39
Porque yo lanzo mi programa 01:00:40
Y me dice 01:00:41
Estos son los clientes que hay 01:00:42
Y te dice 01:00:44
Elige el código cliente 01:00:44
Entonces ahora yo elegiré 01:00:46
O esto 01:00:47
O esto 01:00:48
O esto 01:00:48
Y me dirá 01:00:49
Sobre cual cliente 01:00:53
Quiero trabajar 01:00:55
¿Vale? 01:00:56
Entonces 01:00:57
Sistema 01:00:59
Voy a leer 01:01:02
¿Vale? 01:01:04
String 01:01:06
Cliente 01:01:07
Es igual 01:01:10
Scan.next 01:01:16
He leído 01:01:19
Un cliente 01:01:24
¿Vale? 01:01:26
Perfecto 01:01:26
Sé sobre qué cliente quiero trabajar 01:01:27
¿Ok? 01:01:29
Ahora lo que debería hacer es 01:01:30
Algo parecido a este de aquí 01:01:32
Pero con todos los productos posibles 01:01:34
Para decir 01:01:37
¿Qué producto quieres añadir a ese cliente? 01:01:38
Es decir 01:01:41
Algo parecido a 01:01:42
Siso 01:01:43
Que 01:01:44
¿Qué? 01:01:47
Producto 01:01:49
Quieres añadir 01:01:51
Cliente 01:01:53
Más 01:01:55
Cliente 01:01:58
Y aquí 01:01:59
Producto 01:02:02
¿Sí? 01:02:08
Y luego 01:02:13
Lo que tendré que hacer es 01:02:15
A este cliente 01:02:17
Añadirle 01:02:18
Añadir el producto que he seleccionado 01:02:19
Pero ahora yo aquí 01:02:20
Quiero tener 01:02:22
Un listado 01:02:23
De todos los productos 01:02:24
Para saber cuáles hay disponible 01:02:25
De elegir este 01:02:28
¿Cómo lo hago? 01:02:28
Como antes 01:02:36
¿Vale? 01:02:37
No puedo hacerlo 01:02:38
Si los tengo así 01:02:40
Entonces ¿Qué hago? 01:02:41
Me creo un array 01:02:44
¿Un array de qué? 01:02:46
De materiales 01:02:47
De servicios 01:02:47
De servicios 01:02:48
Premium 01:02:49
Hola 01:02:49
Necesitaría un array 01:02:54
Que pudiera contener 01:03:03
Todos estos tipos de aquí 01:03:04
¿Cuál es el array que puede contener 01:03:06
Todo esto? 01:03:09
Producto 01:03:10
, ¿Vale? 01:03:19
En mi caso yo tengo 01:03:20
Pongo 5 01:03:22
¿Vale? 01:03:23
Este de aquí sería 01:03:24
Productos 01:03:25
De 0 01:03:26
Fijaos que nuevamente 01:03:27
Dentro de 01:03:28
Un array 01:03:29
De tipo 01:03:30
Producto 01:03:31
Puedo poner 01:03:32
Materiales 01:03:33
De tipo 01:03:34
Producto 01:03:35
Puedo poner 01:03:36
Materiales 01:03:37
De tipo 01:03:38
Productos 01:03:39
De tipo 01:03:40
Productos 01:03:41
De tipo 01:03:42
Productos 01:03:43
De tipo 01:03:44
Productos 01:03:45
De tipo 01:03:46
Productos 01:03:47
De tipo 01:03:48
Productos 01:03:49
Productos 01:03:50
Productos 01:03:51
Productos 01:03:52
Productos 01:03:53
Productos 01:03:54
Productos 01:03:55
Productos 01:03:56
Productos 01:03:57
Productos 01:03:58
Productos 01:03:59
Productos 01:04:00
Productos 01:04:01
Productos 01:04:02
Productos 01:04:03
Productos 01:04:04
Productos 01:04:05
Productos 01:04:06
Productos 01:04:07
Productos 01:04:08
Productos 01:04:09
Productos 01:04:10
Productos 01:04:11
Productos 01:04:12
Productos 01:04:13
Productos 01:04:14
Productos 01:04:15
Productos 01:04:16
Productos 01:04:17
Productos 01:04:18
Productos 01:04:19
Productos 01:04:20
Productos 01:04:21
Productos 01:04:22
Productos 01:04:23
Productos 01:04:24
Productos 01:04:25
Productos 01:04:26
Productos 01:04:27
Productos 01:04:28
Productos 01:04:29
Productos 01:04:30
Productos 01:04:31
Productos 01:04:32
Productos 01:04:33
Productos 01:04:34
Productos 01:04:35
Productos 01:04:36
Productos 01:04:37
Productos 01:04:38
Productos 01:04:39
Productos 01:04:40
Productos 01:04:41
Productos 01:04:42
Productos 01:04:43
Productos 01:04:44
Productos 01:04:45
Productos 01:04:46
Productos 01:04:47
Productos 01:04:48
Productos 01:04:49
Productos 01:04:50
Productos 01:04:51
Productos 01:04:52
Productos 01:04:53
Productos 01:04:54
Productos 01:04:55
Productos 01:04:56
Productos 01:04:57
Productos 01:04:58
Productos 01:04:59
Productos 01:05:00
Productos 01:05:01
Productos 01:05:02
Productos 01:05:03
Productos 01:05:04
Productos 01:05:05
Productos 01:05:06
Productos 01:05:07
Productos 01:05:08
Productos 01:05:09
Productos 01:05:10
Productos 01:05:11
Productos 01:05:12
Productos 01:05:13
Productos 01:05:14
Productos 01:05:15
Productos 01:05:16
Productos 01:05:17
Productos 01:05:18
Me dice que producto quieres añadir al cliente C1 01:05:19
Y yo puedo elegir por ejemplo S2 01:05:22
Y acaba porque todavía no lo he hecho 01:05:25
Entonces 01:05:28
Cuando yo llego aquí 01:05:32
Yo tengo un código cliente 01:05:36
Que me define un cliente 01:05:40
Y un código producto que me define un producto 01:05:42
¿Qué hago? 01:05:45
¿Cómo? 01:05:49
Asumamos que sean productos correctos por ahora 01:05:57
Luego ya veremos cómo lo hacemos 01:05:59
Primero busco el cliente 01:06:01
¿Vale? 01:06:05
Busco el objeto cliente 01:06:05
¿Cómo busco el objeto cliente? 01:06:07
Pues me voy 01:06:12
Recorriendo este array de aquí 01:06:13
Y me voy a la página 01:06:18
A la búsqueda del cual es 01:06:19
Esa posición 01:06:21
Que tiene el código correcto 01:06:24
Por lo tanto 01:06:27
Chicos yo esto lo sé hacer 01:06:28
Sois vosotros que no lo sabéis hacer 01:06:35
Van algunos de vosotros 01:06:37
En vez de estar hablando constantemente 01:06:38
Voy a mirar todos los clientes 01:06:42
Sí 01:06:46
Cliente 01:06:49
De I 01:06:53
Punto 01:06:56
Código 01:06:58
Es igual 01:07:00
A clientes 01:07:04
A cliente 01:07:08
Esto 01:07:09
Es el cliente que quiero utilizar 01:07:14
¿Vale? 01:07:16
Entonces 01:07:17
O me recuerdo la posición 01:07:18
O me recuerdo el objeto 01:07:20
¿Vale? 01:07:23
Asumamos que me acuerdo 01:07:25
Que se yo la posición 01:07:27
Int post cliente 01:07:28
Es igual a menos un 01:07:32
Entonces 01:07:35
Post cliente es igual 01:07:39
Ahí 01:07:43
¿Sí? 01:07:44
Me recuerdo que 01:07:48
Cuando encuentro 01:07:49
Que el código de este 01:07:50
Del que estoy mirando 01:07:52
Es efectivamente 01:07:54
El que me han puesto antes 01:07:55
Pues entonces 01:07:56
Me acuerdo esa posición 01:07:57
Para que luego pueda sacar 01:07:59
Ese objeto cliente 01:08:01
¿Vale? 01:08:03
Ahora busco 01:08:04
El producto 01:08:05
Int 01:08:08
Post producto 01:08:09
Es igual a menos uno 01:08:11
Y algo parecido a esto 01:08:15
Productos 01:08:18
Productos 01:08:25
Producto 01:08:29
Y post 01:08:32
Producto 01:08:35
Entonces recorro 01:08:37
Toda la red de productos 01:08:40
Y si encuentro que el producto actual 01:08:42
Que estoy mirando 01:08:44
Su código es igual 01:08:45
Al que me ha dado el usuario 01:08:47
Aquí 01:08:48
Pues entonces me guardo su posición 01:08:49
¿Sí? 01:08:51
Vale 01:08:55
Entonces si llego aquí 01:08:55
Tengo aquí y aquí 01:08:57
Las dos cosas que me sirven 01:09:00
Y puedo preguntarme 01:09:02
Post cliente 01:09:06
Es mayor 01:09:10
Igual a cero 01:09:11
Post producto 01:09:14
Es mayor igual a cero 01:09:18
¿Para qué me sirve este if? 01:09:20
Que estoy comprobando 01:09:26
Que se haya encontrado el cliente 01:09:27
Que se haya encontrado el producto 01:09:32
Porque si no he encontrado 01:09:34
O el cliente o el producto 01:09:36
Pues se habrá quedado a menos uno 01:09:38
Y por lo tanto me dirá 01:09:40
Mira me has puesto un código que no existe 01:09:41
Y lo pondré aquí 01:09:43
Código no existe 01:09:48
¿Sí? 01:09:52
Y si no 01:09:54
¿Qué tengo que hacer aquí? 01:09:56
Post cliente 01:10:00
No perdón 01:10:02
Clientes 01:10:03
De post cliente 01:10:05
Punto 01:10:09
Inserta producto 01:10:11
De productos 01:10:14
Punto 01:10:17
No productos 01:10:18
Post product 01:10:24
¿Sí o no? 01:10:26
¿Qué estoy haciendo aquí? 01:10:30
Estoy diciendo 01:10:32
Vete al cliente este de aquí que he encontrado 01:10:33
Dile 01:10:35
Usa el método que hemos creado prima 01:10:36
Antes de 01:10:38
Insertar producto 01:10:39
¿Y qué producto vas a insertar? 01:10:41
Pues el producto 01:10:43
Que hemos visto antes 01:10:44
Entonces ahora mismo 01:10:46
Este cliente tiene asociado ese producto 01:10:48
Lo ha metido en su 01:10:51
Array de productos comprados 01:10:53
¿Sí? 01:10:56
Y ahora 01:11:07
Al final 01:11:08
Lo que podría hacer es 01:11:12
Calcularme el costo 01:11:15
Para este 01:11:18
Para este cliente 01:11:20
Pero claro tiene un producto solo 01:11:22
Lo dejamos a después 01:11:24
Cuando podemos poner más de un producto 01:11:26
¿Sí? 01:11:27
Por ahora probamos esto 01:11:29
Entonces él me dice 01:11:30
Código del cliente 01:11:33
¿Qué productos quiere poner? 01:11:35
Quiero poner PS4 01:11:38
Pues me dice el código no existe 01:11:39
Vale 01:11:41
Si en vez le digo 01:11:43
Cliente 0 01:11:45
Código 01:11:47
Atatatá 01:11:48
El código no existe 01:11:49
Vale 01:11:50
Si en vez le digo 01:11:51
Cliente 0 01:11:53
Con 01:11:55
M0 por ejemplo 01:11:56
No me dice nada 01:11:58
Algo habrá hecho 01:12:00
Solo que acaba 01:12:01
Pero no me dice el código no existe 01:12:02
Ha encontrado los códigos 01:12:04
¿Sí? 01:12:06
Vale 01:12:08
Entonces 01:12:09
Todo esto 01:12:10
Desde 01:12:11
Desde 01:12:12
Algo 01:12:17
Aquí 01:12:18
Desde aquí 01:12:19
Desde aquí 01:12:23
Que es cuando escribe los 01:12:28
Los clientes 01:12:29
Te hace seleccionar 01:12:31
Y luego lo pone 01:12:32
Pues esto debería estar dentro de un while 01:12:33
¿Sí? 01:12:36
Entonces 01:12:39
Int 01:12:40
O boolean 01:12:42
Seguir 01:12:43
Es igual a true 01:12:46
Wille 01:12:48
Seguir 01:12:50
Hasta aquí 01:12:52
Y antes de empezar aquí 01:12:59
Porque si no seguir sería siempre true 01:13:05
Después de haber insertado algo 01:13:07
Pregunto 01:13:10
Si eso 01:13:11
Quieres 01:13:11
Insertar 01:13:14
Si eres 01:13:16
Seguir 01:13:17
Con el programa 01:13:18
Quieres 01:13:19
Que se yo 01:13:20
Insertar 01:13:21
Otro 01:13:22
Producto 01:13:23
Uno 01:13:24
Y aquí me digo 01:13:28
Que si 01:13:29
Ah no 01:13:30
Tengo que leer 01:13:31
Int 01:13:32
Vale 01:13:48
Seguir es igual a 01:13:51
Scan punto next 01:13:55
Int 01:13:57
drag 01:13:58
Y así 01:13:59
Esto en vez de hacerlo 01:14:01
Boolean 01:14:02
O lo hago como entero 01:14:03
Le pongo aquí 01:14:04
Uno 01:14:07
Y mientras seguir es uno 01:14:08
Entonces cuando llega al final 01:14:11
Me hace esta pregunta 01:14:14
Si yo le pongo 01:14:16
Un 1 01:14:18
Entonces él pone un 1 01:14:18
Dentro de seguir 01:14:21
Vuelve aquí arriba al while 01:14:22
Seguir es 1 01:14:25
Y entra otra vez 01:14:27
Si es cualquier otro número, pues sale 01:14:28
Entonces 01:14:30
Cliente C0 01:14:34
Quiero añadir M0 01:14:38
No existe 01:14:41
¿Por qué no existe? 01:14:43
Porque es minúscula, ¿vale? 01:14:45
Pero dice, ¿quieres insertar otro producto? 01:14:47
Dile sí 01:14:49
Vale, venga, empieza otra vez 01:14:50
Elige el código cliente 01:14:52
No me ha vuelto a escribir esto 01:14:54
Lo he dejado fuera del while 01:14:56
Pues C0 01:14:57
Código producto M0 01:15:01
Pues ahora lo ha insertado, ¿vale? 01:15:03
¿Quieres insertar otro producto? 01:15:06
Sí 01:15:07
A C1 01:15:07
Quiero poner S2 01:15:09
Y luego se acabó 01:15:12
¿Vale? Saqué este menú 01:15:15
Ya me lo está repitiendo 01:15:17
Ya estamos acabando, ¿eh? 01:15:18
Pero el while entonces tiene que ser 01:15:20
Antes de aquí 01:15:23
Para que me describa la lista de clientes 01:15:24
Vale, lo único que me queda 01:15:32
Es, vale, ok, después de haber asociado 01:15:36
Todo esto, vamos a hacer que al final 01:15:39
Cuando salga 01:15:41
Pues me diga 01:15:42
Cada cliente cuánto paga 01:15:45
¿Sí? 01:15:47
¿Cómo lo hago eso? 01:15:50
Por cada cliente 01:15:52
Entonces 01:15:54
Por 01:15:54
Cliente 01:15:57
Es igual 01:16:00
Dos puntos 01:16:03
Clientes 01:16:07
¿Cómo lo hago? 01:16:15
Por cada cliente 01:16:17
Digo 01:16:20
Ciso 01:16:21
Cliente 01:16:23
Más 01:16:26
Código 01:16:33
¿Cómo me calculo su 01:16:34
Cuánto tiene que pagar? 01:16:38
¿Por? 01:16:43
¿Por? 01:16:44
Por 01:16:45
¿Por? 01:16:46
白ote 01:16:47
Reb issued 01:16:47
¿Por qué? 01:16:49
Si es listo 01:16:51
Uau 01:16:51
Pero 01:16:52
¿Estamos bien? 01:17:06
Entonces 01:17:07
Vamos a hacer 01:17:08
Colocas 01:17:09
Sueldo 01:17:11
bridger 01:17:12
Sí 01:17:14
¿Por qué? 01:17:16
Total 01:17:17
Más igual a qué 01:17:21
A C punto 01:17:22
Productos 01:17:26
De I 01:17:28
Punto 01:17:29
Coste 01:17:32
O sea 01:17:34
Me voy por cada cliente 01:17:39
Dentro de cada cliente 01:17:41
Por cada producto que tiene dentro cliente 01:17:42
Os acuerdo que cliente tenía 01:17:45
Un array de productos aquí 01:17:46
Que son los que le he asignado 01:17:48
Pues me va en cada uno de estos señores 01:17:49
De estos productos 01:17:53
Y calcula su coste 01:17:53
Y me lo escribe en pantalla 01:17:59
Total 01:18:02
Dos punto 01:18:07
Más total 01:18:08
Os gusta 01:18:10
¿Veis? 01:18:13
A mí no 01:18:15
Pero funciona 01:18:18
Pero no funciona 01:18:20
A C cero 01:18:23
Le pongo el ordenador 01:18:25
Así 01:18:27
C cero 01:18:28
Le pongo el ordenador 01:18:34
Sí 01:18:36
A C cero 01:18:37
Le pongo también el mantenimiento 01:18:40
Vale 01:18:44
Luego a C1 01:18:45
Le pongo 01:18:47
El mantenimiento plus 01:18:49
Y he acabado 01:18:51
¿Vale? 01:18:54
Entonces 01:18:55
El cliente cero 01:18:56
1613 01:18:57
El cliente uno 01:18:59
1300 01:19:01
¿Vale? 01:19:02
Esto sale de 01:19:04
El coste del ordenador 01:19:06
Más el envío 01:19:08
Y más 01:19:10
El mantenimiento por seis meses 01:19:12
¿Sí? 01:19:14
¿Dudas? 01:19:15
¿Por qué me gusta relativamente? 01:19:17
Porque os recuerdo que el cliente Gold tenía un descuento 01:19:21
Y por ahora aquí no lo he usado 01:19:24
Entonces tengo dos opciones 01:19:27
Y esto es 01:19:30
Esta parte de aquí ¿Vale? 01:19:32
La primera es 01:19:36
Así que 01:19:40
Instancia 01:19:49
Instancia de 01:19:53
Cliente Gold 01:19:55
Si el cliente que estoy mirando es un cliente Gold 01:19:59
Al total 01:20:05
Hazle un descuento del 10% 01:20:08
Es decir que es igual a 01:20:11
Bueno 01:20:13
Menos igual 01:20:14
Total 01:20:15
Multiplicado 01:20:17
A ver 01:20:20
Multiplicado 01:20:21
Cliente 01:20:23
Gold 01:20:25
Punto 01:20:28
Descuento 01:20:34
Divido 100 01:20:35
Si ¿No? 01:20:37
Esto me está diciendo 01:20:43
Ay me he perdido un poco 01:20:44
Mira haz tus cosas 01:20:44
Cuando encuentras un 01:20:46
Si encuentras el cliente Gold 01:20:47
Pues entonces aquí 01:20:50
Haz esto ¿Vale? 01:20:52
Y esto se puede hacer 01:20:54
Ahora toda esta cosa aquí 01:20:54
Es fea 01:20:57
Muy poco elegante 01:20:58
¿Por qué? 01:21:00
¿Cómo lo haríais vosotros? 01:21:03
Que sois elegantes 01:21:05
Exacto 01:21:07
Exacto 01:21:12
Con un método 01:21:14
Public Int 01:21:16
Coste Total 01:21:20
This 01:21:23
Return Total 01:21:31
Tengo el 01:21:41
, cliente 01:21:44
Que lo que hace es 01:21:47
Entrar en sus productos 01:21:50
Y calcularse el coste total 01:21:51
Y devolver el total 01:21:54
¿Vale? 01:21:55
Entonces 01:21:56
El sistema 01:21:57
Se transformaría en 01:21:58
Int total 01:22:01
Es igual 01:22:03
A C punto 01:22:05
Coste total 01:22:07
Y que si soy un cliente Gold 01:22:09
Hago el descuento 01:22:14
Pero vosotros sois mejores que así 01:22:16
¿Vale? 01:22:19
Y entonces os dais cuenta 01:22:21
Que yo en 01:22:24
El coste total 01:22:25
Que uso en cliente 01:22:27
No puedo sobre escribir aquí 01:22:30
Public 01:22:33
Int 01:22:35
Coste total 01:22:37
, Int 01:22:43
Sería 01:22:45
Return 01:22:48
Super 01:22:49
Punto 01:22:51
Coste total 01:22:53
Multiplicado 01:22:54
No menos 01:22:58
Por 01:22:59
10% 01:23:02
Si no 01:23:05
No, eso sería solo lo que quito 01:23:07
Ahora, nosotros tenemos que hacer dos pasos 01:23:10
Int 01:23:12
Total 01:23:13
Es igual a esta cosa de aquí 01:23:14
Y devuelvo 01:23:17
Total 01:23:23
Multiplicado 01:23:26
Total menos 01:23:27
Total multiplicado 01:23:28
Descuento 01:23:31
Dividido 100 01:23:34
cameras 01:23:43
Si el coste total es sobre cliente Gol 01:24:02
Primero me calcula más lo de antes y después hay esto le aplicará el descuento 01:24:07
Lo que implica que el sistema saldrá algo como 01:24:11
Así 01:24:12
Que es mucho más elegante con respecto a la primera versión que hemos hecho. 01:24:13
¿Y por qué esto funciona? 01:24:29
Una palabra. 01:24:32
Una palabra. 01:24:33
Ay, señores. 01:24:38
¿Cómo estáis? 01:24:40
¿Por qué esto funciona? 01:24:43
¡Polemorfismo! 01:24:45
Señores, os veo bastante sufriendo. 01:24:49
Vale. 01:24:53
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial - Compartir igual
Visualizaciones:
9
Fecha:
9 de febrero de 2024 - 13:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 24′ 58″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
465.81 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid