Saltar navegación

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

10 visualizaciones

Más información Transcripción

Descargar la transcripción

La funcionalidad de agregar pedido a un cliente dado su nombre, claro, porque, bueno, no, su clave primaria, la clave primaria de los clientes, ¿cuál va a ser? El DNI es lo que asumimos que es único. Vale, pues primero hay que entender bien, claro, qué es lo que nos están pidiendo. 00:00:00
Pues nos van a dar el DNI de un cliente 00:00:15
Y vamos a ponerle un pedido nuevo 00:00:18
Luego ya primero nos hacemos una idea 00:00:20
Antes de empezar a teclear 00:00:22
De qué es lo que queremos hacer 00:00:24
Vale, pues me van a dar un DNI 00:00:26
Yo tengo un montón de clientes aquí metidos en esta caja 00:00:29
Un montón 00:00:32
Tendré que buscar en la caja hasta que lo encuentre 00:00:33
Vale 00:00:36
Una vez que he encontrado a ese cliente 00:00:37
¿Qué tengo que hacer? 00:00:39
Pedir los datos para un pedido nuevo 00:00:41
y meterlo en la caja de pedidos 00:00:43
de ese cliente. 00:00:46
¿La caja de pedidos de ese cliente cuál es? 00:00:47
Su array de pedidos. 00:00:50
Como todos los clientes 00:00:52
tienen un array 00:00:53
de pedidos, pues por eso lo hemos declarado 00:00:56
aquí arriba en lugar de hacerlo aquí o aquí. 00:00:58
Entonces ya nos hacemos esa primera idea 00:01:00
de qué es lo que habrá que hacer. 00:01:01
Pues pedir un DNI, pedir los datos de un pedido, 00:01:03
buscar en mi array de clientes 00:01:06
hasta que encuentre el que coincide 00:01:08
con el DNI y cuando 00:01:09
lo he encontrado, hago lo que tenga que hacer 00:01:11
para que ese cliente 00:01:14
incorpore el pedido 00:01:15
que acabo de solicitar 00:01:17
en la caja. Bueno, ya me hago una idea de que 00:01:19
tendría que hacer un for para buscar por clientes 00:01:21
y dentro de ese for, una vez 00:01:24
que encontré el objeto, ya meto. 00:01:26
Vale. Una primera 00:01:28
idea en la cabeza tengo que tener de lo que quiero 00:01:30
hacer. Y si para tener 00:01:32
esa primera idea, antes en un papel 00:01:34
me tengo que hacer una especie de diagramita, 00:01:35
pues me lo hago. Pero ya tengo una 00:01:38
primera idea de lo que hay que hacer. 00:01:39
Vale, pues ahora ya en este caso que se va a traducir en pocas líneas, pues empezamos a escribir ya lo bestia. Sin diagramitas y sin nada. Venga, pues caso 3. Vamos a, bueno, yo aquí ya he escrito. Primero vamos a pedir los datos del pedido nuevo. 00:01:41
Le digo, venga, pues dame los datos del pedido nuevo. 00:01:58
Me instancio un nuevo objeto pedido con esos datos. 00:02:04
¡Hala! 00:02:11
Estas dos primeras líneas son para el nuevo pedido. 00:02:12
Ya tengo un nuevo objeto pedido con los datos que acabo de solicitar. 00:02:17
Ahora, ¿qué tengo que hacer con este objeto pedido? 00:02:22
meterlo en el array 00:02:26
con ese objeto pedido 00:02:28
meterlo en el array de quién 00:02:30
de un objeto cliente, claro 00:02:32
vale, y ese objeto cliente 00:02:33
cuál va a ser, para meter esto 00:02:37
en un array de un objeto cliente 00:02:39
tengo que tener ese objeto cliente 00:02:41
para poder acceder a su array y meterlo dentro 00:02:42
pues ese objeto cliente 00:02:44
será uno de estos 00:02:46
uno de estos 00:02:48
cuál va a ser, aquel cuyo DNI 00:02:49
sea igual al que me digan ahora 00:02:52
pues venga, pido el DNI 00:02:54
dime el DNI 00:02:56
para que localice yo ese objeto 00:02:58
ya tengo el DNI 00:03:00
y ahora ya hago lo que ya tenía 00:03:02
vislumbrado en la cabeza que tenía que hacer 00:03:04
me pongo a recorrer mi array 00:03:06
donde están todos 00:03:08
voy uno por uno 00:03:09
oye 00:03:11
este es 00:03:12
aquel cuyo DNI 00:03:16
es igual al que me has pasado 00:03:18
si, es este 00:03:20
este es igual 00:03:22
Pues ahora es cuando digo 00:03:23
Vale, ¿qué hago con este 00:03:26
Cliente? Pues este 00:03:28
Cliente tiene un array pedidos 00:03:30
Que es este de aquí 00:03:31
Y a este 00:03:33
Array pedidos tendré que 00:03:36
Agregarle este pedido nuevo 00:03:38
Para agregar un pedido nuevo a un array 00:03:39
Pues tengo todo el rollo este de 00:03:42
Algún día 00:03:44
Encontraré la llave 00:03:48
Aquí 00:03:49
vale, pues a este array de pedidos 00:03:50
tendré que ver como le meto 00:03:56
a este array este nuevo pedido 00:03:58
luego aquí entre llaves todo el rollo de siempre 00:04:00
un auxiliar con una posición más 00:04:03
copio uno 00:04:05
en otro 00:04:07
etcétera, vale, pues lo podría hacer 00:04:07
aquí y ya está, ¿no? 00:04:10
podría hacer todo ese 00:04:13
rollo de siempre, me voy a hacer 00:04:14
un array de pedido 00:04:17
una array auxiliar 00:04:18
que tenga una posición más 00:04:31
que el array de pedidos 00:04:36
de este 00:04:38
vale, entonces ahora lo de siempre 00:04:41
en este array auxiliar 00:05:11
copio 00:05:13
lo que está en el viejo 00:05:14
para 00:05:17
cada posición 00:05:20
mientras si sea menor 00:05:26
que 00:05:30
cl.getpedidos 00:05:31
length 00:05:38
incrementando i 00:05:40
pues entonces cópiame en el auxiliar 00:05:44
cópiame en el auxiliar 00:05:46
lo que hay en este 00:05:51
lo que hay en este 00:05:53
getpedidos 00:06:00
vale, una vez que 00:06:01
has terminado de copiar 00:06:04
lo que había en el de pedidos 00:06:05
del cliente CL 00:06:07
ahora ya en la 00:06:09
extra que hemos puesto en auxdp 00:06:12
que la extra que hemos 00:06:14
puesto estará aquí 00:06:16
auxdpedidos.led 00:06:17
menos uno 00:06:21
en la extra copia el nuevo 00:06:21
copia el nuevo que acabas 00:06:24
de crear 00:06:30
y ahora 00:06:30
ya todo esto sigue estando dentro del if 00:06:34
y ahora ya 00:06:36
sustituye 00:06:39
cl.set 00:06:40
pedidos, ahora 00:06:42
que los pedidos del cliente 00:06:44
sean ahora 00:06:46
ausdp 00:06:48
y se acabó el if 00:06:49
¿vale? bueno 00:06:52
pues esto en principio 00:06:54
estaría bien 00:06:56
¿qué hemos hecho? localizar 00:06:57
primero en todo el array de clientes 00:07:00
hemos ido uno por uno 00:07:02
hasta que hemos encontrado 00:07:03
aquel cliente cuyo DNI 00:07:06
coincide con el que me han dado 00:07:08
vale, una vez que lo he encontrado 00:07:09
ya sabemos que lo que nos 00:07:12
falta por hacer es 00:07:14
al array de pedidos de ese cliente 00:07:15
que es esto, que lo saco del get 00:07:18
verdad, porque get 00:07:20
pedidos me va a devolver esto 00:07:22
este array 00:07:24
bueno, pues al array de pedidos de este 00:07:24
cliente 00:07:28
hago un auxiliar con 00:07:30
una posición más 00:07:32
copio en el auxiliar lo que hay 00:07:33
en el array de pedidos de ese cliente uno por uno 00:07:36
y en la extra del auxiliar copio el nuevo 00:07:38
y una vez que ya lo he hecho 00:07:41
lo último que me falta es 00:07:43
se me ha borrado el set que he hecho antes 00:07:45
una vez que ya lo he hecho 00:07:48
lo que me faltaba era 00:07:50
que ahora ya mi cliente CL 00:07:52
voy a modificarle su array de pedidos 00:07:55
mediante el set 00:07:57
para que ahora sea el auxiliar que he puesto 00:07:58
en el for no he puesto llaves 00:08:02
porque solo tiene una sentencia dentro 00:08:05
que es live, solo tiene esa 00:08:06
y este ya sería el break 00:08:07
vale 00:08:09
pues esto en principio estaría bien 00:08:11
en principio 00:08:14
los he localizado todos 00:08:16
y he añadido cuando he encontrado el que coincide 00:08:18
el DNI, le he añadido 00:08:20
el pedido p 00:08:22
a su array de pedidos 00:08:23
y le he puesto ese nuevo array 00:08:25
vale, lo que pasa es que 00:08:27
tenemos que empezar a acostumbrarnos 00:08:30
a no hacer códigos 00:08:31
tan largos, hacerlos más modulares 00:08:34
porque un main 00:08:35
con todas las funcionalidades ahí metidas 00:08:37
en mil líneas 00:08:39
pues es un rollo, si tengo 00:08:41
un único código fuente con todo 00:08:43
hecho ahí, cualquier modificación 00:08:45
que haga para cambiar 00:08:47
mi programa, para adaptarlo a otra situación 00:08:49
seguramente 00:08:52
esa modificación va a caer ahí 00:08:53
en ese main que es el que lo tiene casi todo 00:08:55
luego voy a tener que recompilar 00:08:57
todo esto otra vez, etc. 00:08:59
Entonces, mejor si lo voy separando por partes. 00:09:00
Entonces, todo este código que hemos hecho aquí, todo esto, claro, ese código que tengo yo ahí es para agregar un objeto pedido a mi objeto cliente CL. 00:09:05
Bueno, pues voy a hacerme en la clase cliente un método al que yo le pase un objeto pedido y lo agrega a la RAI. 00:09:17
Y, hombre, muchísimo mejor, ¿no? 00:09:23
Porque si es una funcionalidad interesante que voy a usar a 00:09:26
menudo, la de a un cliente agregarle un pedido, 00:09:31
pues voy a ponerla en la clase cliente. 00:09:35
Vale. 00:09:38
Entonces, una vez que decidimos que eso está muy bien, 00:09:39
la parte concreta de a un objeto cliente agregarle un pedido, 00:09:41
esa parte, separarla y llevarla a un método, 00:09:45
ahora ya pensamos, ¿a dónde lo llevo? 00:09:49
bueno, podríamos llevarlo a la clase cliente 00:09:51
si lo llevamos 00:09:54
a la clase cliente 00:09:56
tendremos aquí un método 00:09:57
que sería este 00:09:59
lo llevamos a la clase cliente 00:10:03
la clase cliente, me hago un método 00:10:06
agregar pedido 00:10:08
con un objeto pedido 00:10:09
y me hace exactamente 00:10:12
lo que yo he puesto aquí 00:10:14
esto mismo 00:10:15
me hace exactamente eso 00:10:17
entonces 00:10:20
me hace un auxiliar con una posición más 00:10:25
copia lo que hay en la propiedad pedidos 00:10:28
aquí lo único es que no hace falta que lo 00:10:31
la coja con el get porque estoy en la misma clase 00:10:34
luego tengo acceso a pedidos 00:10:36
aquí cuando lo hacía en main la cogía con el get 00:10:38
pero es la única diferencia, es un copia y pega 00:10:42
de ese código en el otro, es un copia y pega 00:10:44
vale, pues entonces este método auxiliar 00:10:46
en la clase cliente 00:10:49
le pasa un pedido 00:10:51
y lo agrega al array 00:10:52
de la manera en que sabemos agregar 00:10:54
que es, solo hay una 00:10:57
posible, solo hay una 00:10:58
creando uno nuevo con una posición más 00:11:00
copiando lo viejo en el nuevo 00:11:02
en la adicional 00:11:05
en la posición extra, copiar el pedido 00:11:06
nuevo y sustituir 00:11:09
vale, pues entonces hemos ganado mucho 00:11:10
hemos ganado mucho 00:11:13
porque ahora ya cualquiera 00:11:16
que quiera agregar un pedido al cliente lo puede hacer 00:11:18
llamando a este método, cualquiera 00:11:20
desde cualquier clase 00:11:22
desde cualquier aplicación, desde cualquier parte 00:11:24
nosotros en particular desde nuestro 00:11:26
main era justo lo que queríamos hacer 00:11:28
luego todo esto 00:11:30
ya no lo necesito ahí 00:11:31
que me emborrona mi código y me hace un main 00:11:34
feísimo, horrorosamente largo por el cual 00:11:36
me despedirían, ahora yo ya 00:11:38
lo tengo más fácil, porque digo 00:11:40
Claro, digo, oye 00:11:42
CL, acabo de encontrar 00:11:44
El cliente al que quiero 00:11:46
Agregar el objeto P 00:11:48
Ya está, pues, ala, estupendo 00:11:50
Cliente CL 00:11:53
Agrégate el objeto 00:11:54
P que acabo de crear 00:11:57
Y se acabó 00:11:59
¿Vale? En lugar de todo esto 00:12:01
Pues esto 00:12:03
¿Vale? 00:12:03
Vale 00:12:07
ahora 00:12:09
si nos seguimos haciendo preguntas decimos 00:12:11
oye, a ver, cuidado 00:12:14
yo he hecho el método en la clase 00:12:15
cliente, agregar pedido 00:12:18
en cliente, luego cliente 00:12:20
online y cliente tienda 00:12:22
lo tienen tal cual clavado ese método 00:12:23
entonces en 00:12:26
tiempo de ejecución no olvidemos 00:12:28
que en tiempo de 00:12:29
ejecución la máquina virtual mira este 00:12:32
objeto si es cliente tienda 00:12:33
o es cliente online 00:12:36
si pero lo va a tener porque está heredado 00:12:36
entonces la máquina virtual 00:12:40
o sea el compilador 00:12:43
está tan tranquilo porque el compilador 00:12:45
lo que ha mirado es que CL 00:12:47
al estar declarado como cliente 00:12:49
tenga en la clase client 00:12:51
un método agregar pedido y lo tiene 00:12:53
el compilador está tranquilo 00:12:55
ahora cuando ejecutamos esto en la máquina virtual 00:12:56
la máquina virtual ya sabemos que no mira eso 00:12:59
sino lo que mira es CL 00:13:01
como te has instanciado 00:13:03
de qué tipo eres en la memoria RAM 00:13:05
en este momento en concreto 00:13:06
eres cliente tienda, eres cliente online 00:13:08
porque si eres cliente tienda me voy 00:13:10
al agregar pedido 00:13:12
de cliente tienda 00:13:15
que no lo tienes, pero si lo tienes 00:13:15
yo no lo veo 00:13:19
pero lo tienes porque es el heredado 00:13:21
tal cual 00:13:23
¿me vale este? pues sí, me vale 00:13:23
pues ahí lo dejo 00:13:26
¿tú eres cliente online? 00:13:27
pues si eres cliente online 00:13:31
al agregar pedido que voy a llamar yo 00:13:33
es al que tengas aquí, que como 00:13:34
no lo veo, pues me voy al de la 00:13:36
superclase, ¿me vale 00:13:38
este? sí, pues ya está, si me 00:13:40
vale, ya no tengo que hacer nada más 00:13:43
¿vale? 00:13:44
claro, lo que pasa 00:13:47
es que ahora nos preguntaríamos, uy pues con esta 00:13:49
modificación que me han hecho 00:13:51
en cliente online 00:13:52
al pedido le vamos a 00:13:54
cambiar de precio 00:13:57
al pedido no vamos a agregarlo sin más 00:13:57
sino que antes de agregarlo 00:14:00
a la RAI, vamos a 00:14:03
modificar el precio que me has introducido 00:14:05
poniéndole el descuento. 00:14:07
¿Eso qué significa? 00:14:08
Que la versión heredada de cliente, 00:14:10
la versión heredada, 00:14:13
a cliente tienda le vale. 00:14:15
No tiene que sobrescribirla. 00:14:17
A cliente tienda le vale. 00:14:19
Pero a cliente online no le vale 00:14:21
esa versión. No le vale. Entonces, 00:14:22
a cliente tienda no le tocamos porque le vale 00:14:25
la versión heredada, pero 00:14:27
a cliente online la sobrescribimos. 00:14:28
¿Vale? 00:14:32
entonces la sobrescribimos, hacemos un copia y pega 00:14:32
y cambiamos lo que sea para él 00:14:35
vale, pues entonces ¿qué era lo que teníamos 00:14:36
que cambiar? pues a este pedido 00:14:47
le vamos a hacer el descuento 00:14:50
P.setPrecio 00:14:52
que sea igual 00:14:57
a P.getPrecio 00:14:59
menos 00:15:02
el descuento 00:15:02
el descuento como lo habéis interpretado 00:15:05
si es como cantidad total, como porcentaje 00:15:07
que tendría más sentido, porque si no la cantidad total 00:15:09
que sería entonces 00:15:11
menos el descuento, que será 00:15:13
el porcentaje 00:15:15
eso, getPrecio 00:15:16
uy, por 00:15:19
getPrecio por 00:15:20
el descuento 00:15:25
entre 100, si está 00:15:27
en porcentaje 00:15:29
ala, vale 00:15:30
pues lo único que ha cambiado 00:15:36
de la versión 00:15:39
eh, heredada 00:15:40
a la sobrescrita 00:15:43
es añadir esta línea 00:15:45
pero es que hay que hacerlo 00:15:46
no, el descuento va a ser lo que esté en la variable 00:15:47
porque si luego me cambia en la aplicación 00:15:53
claro, al rato me meten 00:15:55
la opción 5 de cambiar, pues a partir de ahí 00:15:57
los siguientes pedidos van con otro descuento 00:15:59
distinto 00:16:01
lo único que me ha cambiado es esto 00:16:02
pero tengo que sobreescribir 00:16:06
el método entero 00:16:09
esto no es reutilizo parte del código 00:16:09
bañado, no, sobre escribo 00:16:13
borro y hago 00:16:15
de cero, la sobre escritura de métodos 00:16:16
va así, de cero 00:16:19
vale 00:16:20
si no sería un desmadre, un lío 00:16:22
muy lioso 00:16:25
claro, ya sería el colmo 00:16:25
de la complicación 00:16:31
aún así 00:16:31
no es que todo en Java o en cualquier otro lenguaje 00:16:35
esté bien pensado y todo digamos 00:16:37
ah sí, claro, habrá cosas 00:16:39
que hay muchas cosas que se podrían 00:16:41
haber solucionado de otra manera, pero bueno 00:16:43
más o menos casi todo 00:16:45
tiene un cierto sentido 00:16:46
ala, pues ya está 00:16:47
entonces ahora ya, esto en tiempo 00:16:51
de ejecución, si CL 00:16:52
es de tipo cliente tienda, llamará 00:16:54
la versión heredada, pero si 00:16:56
CL es cliente online, llamará la sobrescrita 00:16:58
y todo funcionará 00:17:01
perfectamente y estupendo 00:17:02
¿vale? 00:17:04
aquí sí que no tiene sentido 00:17:06
esta en la 00:17:08
super clase dejarla vacía 00:17:10
porque es que cliente tienda si que la está utilizando 00:17:12
la de mostrar datos es que no 00:17:15
no se la he puesto 00:17:17
pero se la podría poner 00:17:21
y quedaría más bonito 00:17:22
pero vamos 00:17:25
si se la pongo pues bueno voy cogiendo 00:17:26
quizá el hábito de que las anotaciones son algo 00:17:30
que existe y que los compiladores 00:17:33
tienen en cuenta para hacer 00:17:35
comprobaciones y rollos 00:17:37
vale 00:17:38
bueno pues ya está 00:17:40
agregar pedido 00:17:45
y ahora para comprobar 00:17:48
realmente si, bueno 00:17:50
podemos hacer una comprobación rápida por si algo 00:17:51
lo hemos escrito mal 00:17:54
y nos sale null pointer exception 00:17:55
por ahí de todo 00:17:58
insertamos un cliente de tienda 00:17:59
que se llama 11 00:18:02
y vive en 11 00:18:06
y ahora vamos a insertar 00:18:07
un cliente online 00:18:09
que se llama 00:18:11
su DNI es 22, se llama 22, paga con 22 00:18:13
y su email es 22, vamos a mostrarlo, a ver si están 00:18:17
realmente, si ahí están 00:18:21
está el primero, que es este, y el segundo, que es este 00:18:22
venga, vamos a agregar un pedido a un cliente, 3 00:18:28
agregamos un pedido a un cliente 00:18:32
pues venga, el pedido 1, con descripción 1 00:18:37
y precio 1 00:18:41
aquí el cliente al 1, 1 00:18:42
no salen errores de ejecución, no tenemos métodos 00:18:46
para verificar que lo esté haciendo bien, pero al menos errores 00:18:48
de ejecución no salen 00:18:50
vale, y voy a 00:18:52
agregar un pedido al otro cliente 00:18:54
por si acaso 00:18:57
el método sobre escrito está mal, pues venga 00:18:57
un pedido 2 con descripción 00:19:00
2, que valga 2 00:19:02
¿a quién? al cliente 00:19:05
2, 2 00:19:06
para verificar DNI 00:19:07
en concreto en la máquina 00:19:14
virtual de Java no lo sé, lo que sí 00:19:16
que hay es servicios web 00:19:18
es decir 00:19:20
un servicio web 00:19:22
es un programita 00:19:24
de Java sencillísimo 00:19:26
que está a disposición de un servidor 00:19:27
y no está pensado para que 00:19:30
acceda a un usuario de un navegador 00:19:32
está pensado para que acceda a un programa 00:19:33
claro, esa es la diferencia 00:19:36
entre aplicación web y servicio web 00:19:38
la aplicación 00:19:40
web está pensada para que un tío sentado 00:19:42
aquí en un navegador interaccione 00:19:44
con ella. El servicio web es lo mismo 00:19:46
en el sentido de que es código, pero 00:19:48
está pensado para que tú lo invoques 00:19:50
desde la aplicación. 00:19:51
Ah, pues ya está. 00:19:54
Entonces, servicios web para verificar 00:19:56
DNI para todos. 00:19:57
En el Ministerio de Interior, seguro que 00:19:58
hay un servicio. Otra cosa es que esté 00:20:02
solo para desarrolladores. 00:20:03
Yo cuando estaba en el Ministerio de Educación 00:20:07
usaba ese servicio web 00:20:08
desde mis aplicaciones para verificar un DNI. 00:20:09
Pero, claro, imagino que hay una serie de permisos y protocolos para... 00:20:12
¿Puedes llamar al servicio web directamente desde código? 00:20:16
Claro, lo llamas desde código, instancias un cliente de servicio web y lo llamas. 00:20:18
En dos líneas, te hace esa función y se acaba. 00:20:23
¿Vale? 00:20:26
No, pero tampoco creo que sea difícil. 00:20:27
Al menos el cálculo de letras y todo eso. 00:20:32
Supongo que no, no. 00:20:34
Vamos, apides a HGPT o la buscas y seguro que es rápida. 00:20:36
Y hacerla uno, no lo sé. 00:20:39
Pues no sé cómo es la función, pero bueno, es difícil. 00:20:41
vale, pues valores de ejecución no tiene 00:20:44
bueno 00:20:47
la 4 00:20:48
la 4 sobre todo en realidad 00:20:52
aquí estaba pensada para que no se os olvidara 00:20:55
programar 00:20:57
pues hacer el máximo, hacer no sé qué, hacer no sé cuántos 00:20:58
sobre lo que hemos hecho en la 3 00:21:01
¿algún problema? 00:21:03
suena amenazador 00:21:07
¿algún problema con esto? 00:21:08
pues me lo cuenta afuera 00:21:12
Vamos afuera 00:21:13
Ay, ni media torta tengo contigo 00:21:14
En fin 00:21:17
A ver 00:21:18
Es que algo no me quedó claro 00:21:20
¿Qué no te quedó claro? 00:21:25
Es que yo lo estaba haciendo 00:21:26
Muy bien 00:21:27
¿No? Fenomenal 00:21:30
A ver, tú hiciste 00:21:32
¿Has hecho un método aparte con agregar pedido 00:21:38
o lo has hecho todo en el main? 00:21:41
Ah, hiciste un método en el main para agregar pedido 00:21:43
Ah, vale, ya has hecho el método en cliente 00:21:50
Para que lo llame un objeto cliente 00:21:55
Y agregue el pedido ahí 00:21:57
Vale, lo único que he hecho es 00:21:58
Como los clientes online 00:21:59
El precio del pedido P 00:22:02
Se va a cambiar por un descuento que tienen aquí 00:22:03
Porque el cliente online tiene un descuento aquí 00:22:07
pues entonces 00:22:10
este método de agregar pedido tal cual no vale 00:22:12
porque antes de meter el pedido en el array 00:22:15
antes de meterlo, le vamos a hacer un descuento 00:22:16
entonces como este método 00:22:19
tal cual no vale porque le falta 00:22:21
agregar ese descuento, en la clase 00:22:23
cliente online 00:22:25
lo he sobrescrito por esta otra versión 00:22:26
que lo único que hace es añadir esta línea 00:22:29
al principio, es lo único que hace 00:22:31
que es una línea 00:22:33
que cambia el precio del pedido 00:22:34
lo cambia con el set 00:22:37
lo cambia a un precio 00:22:38
que descuenta el descuento 00:22:41
ya está, he añadido esa línea 00:22:43
y se acabó, así la versión 00:22:45
de cliente online es distinta 00:22:47
vale, la otra funcionalidad 00:22:49
es para ver si nos acordamos de programar 00:22:53
¿qué nos acordamos? 00:22:54
programar 00:22:57
respirar no necesitas 00:22:57
pero programar 00:23:02
te digo yo que lo vas a necesitar 00:23:04
vale 00:23:05
pues a ver, funcionalidad 00:23:06
cuatro. A ver 00:23:10
si nos vamos de aquí muy a gusto. 00:23:12
Con todo 00:23:15
hecho y entendido. 00:23:16
Para mañana venir con 00:23:18
muchas ganas de... 00:23:19
Enséñanos cosas. Que no aguantamos 00:23:21
más. Venga. 00:23:24
Caso cuatro. 00:23:27
Vale. Cliente que 00:23:32
más ha gastado. En todos sus pedidos. 00:23:34
Así, a lo bestia. 00:23:36
Siempre nos preguntamos, porque 00:23:38
es esa la funcionalidad, ¿no? ¿El cliente qué más ha gastado? 00:23:40
No, es el pedido que más ha costado. 00:23:42
No, el que más se ha gastado 00:23:44
en sus pedidos. Vale. 00:23:46
Entonces, vamos perfilando en nuestra 00:23:48
cabeza la idea de lo que hay 00:23:50
que hacer aquí. Claro, primero 00:23:52
siempre pensamos, ¿necesito datos 00:23:54
de entrada? Pues no. 00:23:56
Mis datos están en mi array 00:23:58
de clientes. Yo tengo que meterme ahí 00:24:00
a operar a ver cuál es el que más ha gastado. 00:24:02
Entonces, no hay que pedirle nada al usuario. 00:24:04
Cuando el usuario 00:24:07
de la opción 4, no se le va 00:24:07
a pedir nada, simplemente se le va a decir el que más ha gastado 00:24:10
es Pepito. Vale. 00:24:12
Primera cosa. 00:24:14
Sí, ahora 00:24:16
ya hemos perfilado 00:24:17
eso primero, que no hay que pedirle nada, 00:24:20
afortunadamente. Ahora, ¿qué es lo que tenemos que hacer? 00:24:21
Un máximo. 00:24:24
Un máximo de algo siempre implica 00:24:26
recorrer un conjunto 00:24:28
de datos para ver cuál de ellos 00:24:29
es máximo en algo. 00:24:31
¿Vale? Entonces, hemos 00:24:34
identificado, hay que hacer un máximo, luego 00:24:35
lo siguiente es identificar cuál es 00:24:37
mi conjunto de datos en el cual 00:24:39
tengo que buscar el máximo 00:24:41
mi conjunto de datos en el cual tengo que 00:24:42
buscar el máximo es mi cajita de clientes 00:24:45
vale 00:24:48
pues tendré que recoger 00:24:48
mi caja de clientes 00:24:51
a ver uno por uno 00:24:53
a ver, podemos partir 00:24:55
de partida que el gasto máximo es 00:24:57
cero, porque asumimos que gastos negativos 00:24:59
no hay, gasto máximo es cero y ahora voy cliente por 00:25:01
cliente 00:25:03
para cliente cero 00:25:04
¿has gastado más que el máximo? 00:25:06
si actualizo, no, no actualizo 00:25:08
ese es el algoritmo de siempre 00:25:11
bueno, pues una vez que lo tenemos 00:25:13
perfilado ya empezamos a programarlo 00:25:14
vale, el resultado de 00:25:16
donde estoy, aquí 00:25:19
el resultado 00:25:22
de mi algoritmo tiene que ser 00:25:24
encontrar un objeto cliente 00:25:27
que sea el que más se haya gastado, este 00:25:29
vale, inicialmente 00:25:32
no lo tengo, null 00:25:35
porque cuando ya lo tenga 00:25:36
lo que tendré que mostrar será 00:25:39
simplemente esto, claro 00:25:40
el cliente que más 00:25:42
ha gastado y al que tienes que darle 00:25:46
una cesta de navidad 00:25:49
a mi 00:25:51
que me gasto mucho en gilipolleces 00:25:55
que más ha gastado 00:25:57
clmax.getNombre 00:25:59
y te dice 00:26:05
si y además di si es de tienda o online 00:26:09
vale, primero mostramos el nombre 00:26:12
o sea, nos falta por supuesto 00:26:14
toda la parte de calcularlo de verdad 00:26:16
pero perded 00:26:17
si no lo habéis perdido ya, perded la idea 00:26:19
de que se programa en secuencia 00:26:22
no se programa en secuencia 00:26:24
no, se programa por 00:26:25
iteraciones 00:26:28
aproximaciones sucesivas 00:26:28
uno se va haciendo su esquemita 00:26:31
su estructura, su... y va rellenando 00:26:33
las cosas, porque eso es lo que le da 00:26:36
sentido a lo que está haciendo 00:26:37
vale, pues nosotros en algún momento 00:26:39
averiguaremos quién es ese, en algún momento 00:26:41
lo averiguaremos, pero cuando ya lo 00:26:43
tengamos, mostraremos 00:26:45
su nombre 00:26:47
y además tenemos que ver si es tienda 00:26:49
online, pues 00:26:51
pues no sé, CL máximo está declarado 00:26:53
como cliente sí o sí, ¿cómo puedo 00:26:55
saber además cómo está instanciado? 00:26:57
claro, con el operador de ayer 00:27:00
pues hombre, vamos a ver 00:27:01
si este tío 00:27:03
se instanció 00:27:05
como 00:27:08
cliente 00:27:09
tienda, pues 00:27:12
entonces le dices aquí 00:27:16
es de tienda 00:27:18
para ya hacer con él lo que haya que hacer 00:27:19
y si no 00:27:21
si se instanció 00:27:25
como cliente online 00:27:27
pues entonces ya le decimos 00:27:33
pues no, es online 00:27:46
haz con él lo que toque 00:27:47
y deja al cliente por defecto 00:27:49
por si acaso alguien crea cliente 00:27:53
claro, podríamos hacer 00:27:55
si no está instanciado ni como tienda 00:27:56
ni como online 00:27:59
es que es un cliente genérico 00:28:00
podría hacerse un cliente, abre mi aplicación 00:28:03
tal y como está ahora 00:28:05
no lo contemplo porque en el insertar 00:28:06
cliente le estoy obligando a que se atienda 00:28:09
pero esta aplicación se podría ampliar 00:28:11
y si se amplía 00:28:13
la funcionalidad de insertar cliente 00:28:15
esta parte tendría que modificarla 00:28:17
si no lo he puesto ese else 00:28:19
vale y si no 00:28:21
pues es porque es cliente seguro 00:28:23
y le diría pues nada 00:28:25
genérico como lo queráis llamar 00:28:27
vale que en mi caso repito nunca vas a ir 00:28:35
a esa opción porque solo tengo 00:28:37
o new cliente tienda o new cliente online 00:28:38
en mi aplicación vale 00:28:40
pues la parte final de nuestro 00:28:42
programa lo que es la vista 00:28:45
ya la tenemos hecha 00:28:47
ahora como hacemos 00:28:48
el máximo pues ahora ya se que 00:28:51
viene aquí el algoritmo de máximo 00:28:53
y esto siempre es lo mismo 00:28:54
como ya sabemos 00:28:56
que tengo que recorrer 00:28:57
mi array de clientes 00:28:58
para cada array de clientes 00:28:59
para cada cliente 00:29:02
que tengo que hacer 00:29:03
pues para cada cliente mío 00:29:04
en clientes 00:29:07
pues que tengo que hacer 00:29:13
para cada cliente 00:29:16
lo que se ha gastado el cliente 00:29:17
es mayor 00:29:20
que el máximo hasta ese momento 00:29:21
a el máximo hasta ese momento 00:29:24
variable aparte 00:29:26
inicialmente el máximo empieza siendo 0 00:29:27
vale 00:29:30
aquí tendría que poner 00:29:31
lo que se gastó CL 00:29:33
es mayor que el máximo 00:29:35
porque si lo que se gastó CL 00:29:43
es mayor que el máximo 00:29:45
tengo nuevo máximo 00:29:46
que es lo que se gastó CL 00:29:48
y tengo nuevo 00:29:51
cliente máximo, que es este 00:29:56
ya no es null, sino que va a ser este 00:29:58
luego este es mi algoritmo, ¿no? 00:30:00
el de siempre 00:30:02
voy en todo 00:30:03
el rango de valores 00:30:06
en el que quiero encontrar cuál es el máximo 00:30:07
para cada uno de ellos 00:30:10
miro si cumplen la propiedad 00:30:11
de ser máximo hasta ese momento 00:30:13
lo cumplirán en este 00:30:15
caso si lo que se han gastado es mayor 00:30:18
que el máximo hasta ese momento, que inicialmente 00:30:19
será cero 00:30:21
¿qué es mayor? tengo nuevo máximo 00:30:22
hasta ese momento, tengo nuevo máximo 00:30:25
y además tengo nuevo cliente 00:30:27
que lo cumple 00:30:30
vale 00:30:30
¿qué me falta para completar este algoritmo? 00:30:32
pues calcular lo que se gastó CL 00:30:35
lo que se gastó CL 00:30:36
implica entrar dentro de CL 00:30:39
hacer una suma acumulativa 00:30:41
de todos los precios, de todos los pedidos 00:30:42
hombre, ponerme a meter 00:30:44
aquí todo ese código de hacer la suma acumulativa 00:30:46
y todo eso 00:30:49
ya es meter ahí demasiada basura 00:30:49
entonces 00:30:52
como eso es algo que afecta 00:30:54
a un cliente, que es lo que se ha gastado 00:30:56
el cliente Pepito 00:30:58
pues automáticamente tiene un sitio natural para ser metido 00:30:59
que es en la clase cliente 00:31:02
las cosas que hace un cliente 00:31:05
como ver lo que ha gastado, insertar un pedido 00:31:07
todas esas funcionalidades relativas a un único cliente 00:31:09
tienen un sitio natural para ubicarse en sus métodos 00:31:12
que es la clase cliente 00:31:15
pues venga, vamos a hacer un método en la clase cliente 00:31:16
que me devuelva lo que se ha gastado 00:31:19
ese objeto cliente en sus pedidos 00:31:22
vamos a hacer aquí ese método 00:31:25
como lo voy a tener que llamar desde fuera 00:31:28
como me va a devolver 00:31:31
la suma de precios pues me devuelve 00:31:32
un double 00:31:35
gasto total en pedidos 00:31:35
necesita datos de entrada 00:31:41
el método, no necesita datos de entrada 00:31:44
porque lo único que hace es sumar lo que hay aquí 00:31:46
es lo único que hace 00:31:48
pues venga 00:31:50
dígame 00:31:52
que? 00:31:54
ah, porque lo hicimos en su momento 00:31:54
cuando dije, a lo mejor nos viene bien 00:31:58
¿cómo pudimos prever el futuro 00:32:00
de esa manera? 00:32:02
bueno, a veces pasa 00:32:04
vale, pues ya lo teníamos 00:32:05
fíjate que bien 00:32:08
teníamos un método 00:32:09
¿se te dio copiar? 00:32:12
vale, pues tenemos un método 00:32:19
que en una suma acumulativa va sumando 00:32:20
los precios y todo, los pedidos ya lo teníamos 00:32:22
pues como ya lo tenemos 00:32:24
aquí ya lo que se gastó 00:32:27
es CL punto 00:32:30
dame algo 00:32:32
que pena 00:32:36
no pero 00:32:38
está en cliente el método 00:32:44
get cost total 00:32:46
pedidos, ah porque tengo 00:32:48
errores de sintaxis ahí 00:32:50
almacenados 00:32:51
aquí lo tengo después 00:32:54
es un mayor que, entonces cuando ya hay otros 00:32:56
valores de sintaxis relacionados 00:32:58
ya dice, que te voy a ofrecer 00:32:59
si ya todo es un desastre lo que tienes hecho 00:33:02
vale, entonces 00:33:04
lo que se gastó CL es esto 00:33:08
esto es lo que se gastó CL 00:33:10
pues si lo que se gastó 00:33:11
CL es mayor que el máximo 00:33:14
tenemos nuevo máximo, que es lo que se 00:33:15
gastó CL, esto de aquí 00:33:18
vale, tenemos 00:33:19
que asegurarnos de que el coste total 00:33:27
de los pedidos, el 00:33:29
método que hemos hecho aquí 00:33:31
es válido para cliente online y tienda 00:33:32
por la manera tal cual 00:33:35
y hombre sí que es válido 00:33:36
porque una vez que ya 00:33:38
hemos insertado el pedido 00:33:42
ya se hizo la modificación del descuento 00:33:43
luego el array de pedidos tiene el precio verdadero 00:33:45
entonces para calcular el coste total de los pedidos 00:33:47
en cliente online y tienda 00:33:50
es que se va a hacer así en ambos 00:33:51
no hay ningún cambio, se va a hacer así 00:33:52
pues lo hacemos en la super clase y no tenemos ni que sobre escribir 00:33:53
vale 00:33:57
y ahora ya nuestro main 00:34:00
ya tiene el algoritmo del máximo 00:34:03
y se acabó 00:34:05
y ya está 00:34:06
pues nada, todo muy corto 00:34:07
si probamos por si acaso 00:34:16
hemos puesto alguna burrada 00:34:19
vamos a insertar uno de cada 00:34:20
uno de tienda 00:34:22
uno que 00:34:26
DNITT se llama TT 00:34:29
y vive aquí 00:34:33
y ahora vamos a hacer 00:34:33
uno online 00:34:37
que su DNI es 00:34:38
o se llama así, paga así 00:34:41
y su email es este 00:34:43
vamos a agregar un pedido a cada uno 00:34:44
uno más caro que el otro 00:34:47
venga, pues el pedido 1 00:34:49
con descripción 1 00:34:53
que vale todo esto 00:34:55
se va a ir al 00:34:57
cliente de tienda, que era este 00:34:59
y ahora 00:35:01
agregamos otro pedido 00:35:03
2, descripción 2 00:35:05
con precio 2 00:35:12
al online 00:35:13
que era este 00:35:14
vale, entonces 00:35:16
el que más se ha gastado es el de tienda 00:35:20
porque le he metido 00:35:23
un pedido que vale todo esto 00:35:26
es el que más se ha gastado 00:35:28
el de tienda, me tiene que salir 00:35:29
que el que más se ha gastado se llama 00:35:31
este 00:35:33
y que es de tipo tienda 00:35:35
eso es lo que me tiene que salir 00:35:39
cuatro 00:35:41
el que más se ha gastado es 00:35:43
este y es de tipo tienda 00:35:47
descuento 00:35:49
me ha ido a la opción, ah porque no he puesto un break 00:35:52
no he puesto un break 00:35:54
no he puesto un break, ¿por qué no me decís 00:35:55
esas cosas? entonces si no pongo un break se va a la opción 00:35:59
5 automáticamente 00:36:01
en los switch case siempre 00:36:02
que pensábamos que ya lo tenía 00:36:04
por defecto 00:36:06
como tú quieres que no 00:36:09
siempre utilicemos el break 00:36:13
lo tenía controlado, lo he hecho a propósito 00:36:14
para ver si os dabais cuenta 00:36:16
Pero no os habéis dado cuenta 00:36:18
Sí, sí, me lo dicen a menudo 00:36:24
Bueno, a ver 00:36:28
Ya está, ¿vale? 00:36:29
Está todo bien, ¿no? 00:36:35
Todo entendido 00:36:38
Los que se sentían perdidos 00:36:39
Se han reencontrado un poco 00:36:41
Sí, seguro 00:36:43
Tú no 00:36:44
¿Y qué hubieras necesitado? 00:36:47
menos subir y bajar 00:36:48
tal vez, ¿no? 00:36:51
o hacerlo más despacio 00:36:53
bueno, estás en el momento en el cual 00:36:55
podemos irnos a algún punto en concreto 00:36:59
a ver 00:37:00
en el caso 2 00:37:05
en el caso 2 00:37:07
mostrar datos, ¿qué le pasa? 00:37:13
esto está comentado todo 00:37:16
¿qué otro? 00:37:18
claro, mostrar datos 00:37:26
está hecho en la clase 00:37:28
cliente 00:37:30
y luego está sobrescrita también 00:37:31
en cliente online 00:37:34
y está sobrescrita 00:37:35
en cliente tienda, porque cada uno tiene 00:37:38
su propio mostrar datos 00:37:40
¿vale? de todas formas esta aplicación 00:37:41
esta versión tal y como está 00:37:44
la subo ahora a la aula virtual 00:37:46
Bueno, no hay dudas, ni hay nada 00:37:48
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
16 de enero de 2025 - 17:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
37′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
178.27 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid