Saltar navegación

20250318 Planteam_AppPedidos_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 21 de marzo de 2025 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Hablando de tareas de detectives, poniéndonos ya el colmo de pesquisas, esto ya es lo último que a mí se me ocurre para hacer este método hiper-mega-imposible que se rompa. 00:00:00
¿Se os ocurre alguna otra razón por la que este método podría romper la aplicación? No. 00:00:19
p2 igual a nul imposible 00:00:25
no lo puede romper 00:00:27
p igual a nul no puede 00:00:29
si p no es nul p.setCódigo 00:00:30
no puede romperlo 00:00:33
si p2 no es nul p.setCódigo no puede 00:00:34
y secuenciaCode más más 00:00:37
tampoco puede romperlo, es imposible 00:00:38
conclusión 00:00:40
este método jamás nunca va a hacer 00:00:43
que la aplicación pare ni termine 00:00:45
¿verdad que no? 00:00:46
que alguien modifique accediendo a 00:00:47
a secuenciaCode 00:00:50
por un número negativo 00:00:51
bueno, pero el put se va a hacer 00:00:54
igualmente, o sea, lo que es 00:00:57
parar la aplicación y romperla porque 00:00:59
haya una excepción, un null pointer excepción 00:01:01
un array indesbono excepción 00:01:03
claro, que funcione mal, sí 00:01:04
que funcione mal, sí, que tenga un mal funcionamiento 00:01:06
claro, pero es que efectivamente 00:01:09
para ya evitar el máximo del mal funcionamiento 00:01:11
tendríamos que 00:01:14
verificar que la inserción 00:01:15
se ha hecho, vale, no está mal visto 00:01:17
efectivamente, alguien 00:01:20
puede haber toqueteado 00:01:21
la secuencia, no, más fácil que eso 00:01:24
pedidos 00:01:26
esto te devuelve 00:01:29
el objeto que ha 00:01:32
insertado, ¿verdad? 00:01:34
entonces, pedido 00:01:35
te devuelve 00:01:38
sí, pero 00:01:39
anulreturn 00:01:42
anulreturn 00:01:44
las demás previas a la sociedad 00:01:47
vale 00:01:49
entonces, quiero detectar 00:01:51
que este ha hecho una inserción real 00:01:53
porque si alguien hubiera tocado el código 00:01:55
y ya existiera, el put no habría 00:01:57
funcionado y la interfaz gráfica 00:01:59
se ha creído que lo ha insertado y no lo ha insertado 00:02:01
a ver, los de atrás 00:02:03
Gerardo, cállate 00:02:06
vale 00:02:09
no, estaba hablando 00:02:10
hace 00:02:15
Gerardo es el que le estoy viendo 00:02:17
bueno, pues 00:02:21
igual que tu compañero 00:02:25
vale, a ver 00:02:27
a ver, averiguadme rápido 00:02:29
listillos 00:02:35
que de qué manera puedo averiguar 00:02:37
con el valor de retorno del put 00:02:40
si se ha hecho una inserción real 00:02:41
o no se ha hecho porque el código ya existía 00:02:43
sí, pero no, pero es que lo he hecho a propósito 00:02:46
para que me saliera la ayuda, ahora lo quito 00:02:50
para que me saliera la ayuda 00:02:51
vale 00:02:53
vale 00:02:56
te devuelve 00:03:02
el valor previo 00:03:04
asociado a la key o null 00:03:06
si no había 00:03:08
si ese objeto no estaba 00:03:10
vale, o sea te devuelve null 00:03:12
si no existe 00:03:14
y si existe, te devuelve el que había 00:03:15
previamente 00:03:18
¿vale? eso es lo que me dice aquí ¿o no? 00:03:19
Dios santo bendito 00:03:25
del amor 00:03:37
¿qué? 00:03:39
pero ¿y dónde están tus gafas? 00:03:46
pero tienes que ir 00:03:52
a ver que los informáticos 00:03:53
acabáis todos de gatos perdidos 00:03:57
bueno, así estoy yo, claro 00:03:59
así estoy 00:04:01
yo no veo de lejos 00:04:02
yo no veo de lejos 00:04:06
vale, a ver 00:04:08
el método 00:04:09
silencio 00:04:12
el método put 00:04:16
no, se está sirviendo para recordarlo, no como funciona 00:04:17
put, ya sabéis que 00:04:21
si existe ya un elemento 00:04:23
con esa clave 00:04:25
te lo sustituye 00:04:26
por el nuevo objeto, te lo sustituye 00:04:28
pero te devuelve el antiguo 00:04:30
por si quieres tú hacer algo con el antiguo 00:04:32
te lo devuelve 00:04:34
y si no existía, te devuelve null 00:04:35
¿vale? te devuelve null 00:04:38
si no hay ningún objeto para esa clave 00:04:40
y te devuelve el valor 00:04:43
anterior asociado a esa clave 00:04:45
si ya existía 00:04:46
sí, el propio método put 00:04:47
bueno, pues por eso he entrado 00:04:49
para ver si podemos usarlo 00:04:53
a través de su valor de retorno 00:04:54
para ver si se hizo una inserción 00:04:56
efectiva o no. Vale, pues ya 00:04:57
lo siento 00:05:00
Pablo, vas a... 00:05:02
Bueno, vamos a hacértelo grande. Vale. 00:05:04
Gracias, hombre. 00:05:09
Es lo más bonito que me han 00:05:11
dicho nunca, ¿eh? 00:05:12
Vale, pues entonces 00:05:14
pedidos es 00:05:17
igual a nul, 00:05:19
entonces se hizo la inserción 00:05:22
efectiva. 00:05:24
¿Vale? 00:05:25
entonces se hizo la inserción efectiva 00:05:26
lo incrementamos 00:05:28
y devolvemos true 00:05:30
y si no es igual a null 00:05:32
pues entonces 00:05:34
para avisar 00:05:36
de que 00:05:43
de que el pedido ya existía 00:05:45
entonces bueno, a ver 00:05:48
a ver que todo esto ha sido 00:05:50
sí, sí, sí, o sea, por tu culpa 00:05:52
que sí, ya sé que no está bien 00:05:54
porque el pedido se va a acabar 00:05:56
vale, pero esto todo ha sido por tu culpa 00:05:57
porque yo estaba 00:06:00
pero yo estaba preguntando otra cosa 00:06:01
yo estaba preguntando 00:06:04
¿hay alguna razón más por la que esto 00:06:05
podría parar la aplicación, romperla? 00:06:08
no la hay, esto podría hacer un mal 00:06:10
funcionamiento, pero para evitar ese mal funcionamiento 00:06:12
es que se encadenan muchas acciones 00:06:14
ahora que no nos apetece 00:06:16
porque tendríamos que efectivamente deshacer 00:06:18
el put, para que el pedido se quede 00:06:20
avisar de otra manera 00:06:22
porque el falsi se queda muy genérico 00:06:23
entonces esto 00:06:25
que nos ha sugerido, vamos a dejarlo 00:06:27
porque nos desencadena un montón de acciones 00:06:30
no pasa nada, tú darle a control Z 00:06:33
ala, ya está 00:06:35
pero bueno 00:06:39
se te está moviendo el cerebro 00:06:48
que es lo que se tiene que mover 00:06:49
si, supongo que si 00:06:51
si, son muy sanos 00:06:52
si, estáis siguiendo las ideas 00:06:55
de alguna manera 00:07:01
las, vale 00:07:02
bueno pues ya está, este inserpedido 00:07:03
nos hemos detenido un poquito en él 00:07:05
nos hemos detenido un poquito en él 00:07:07
en este inserpedido simplemente pues para ilustrar 00:07:09
que uno a veces 00:07:12
hace un método y se queda tan ancho y luego 00:07:14
ese método que es tan inocente 00:07:16
puede hacer que la aplicación 00:07:17
papapapacasque por un montón de chorradas 00:07:19
entonces no está mal darle un poquito de robustez 00:07:22
y por supuesto 00:07:24
siempre es importante darle un 00:07:25
mecanismo de realimentación al que lo llama 00:07:28
vale, el que lo llama tiene que ir a alguna 00:07:30
realimentación, no puede llamarte 00:07:32
y ser pedido y confiar 00:07:34
en que lo has hecho bien 00:07:36
realimentación boolean o excepción 00:07:37
vale 00:07:40
y aquí la parte de hacerlo robusto 00:07:40
pues se reduce a esto, estas dos cosas 00:07:44
pueden ser null, pues vamos a hacerlo 00:07:46
robusto de tal manera que si es null 00:07:48
oye, falso, no he hecho nada 00:07:49
y si no es null, le pongo 00:07:51
el código al pedido, lo inserto en 00:07:54
los datos 00:07:56
habilito la secuencia y true, vale 00:07:56
y como conclusión, efectivamente 00:07:59
como alguien me esté toqueteando la secuencia 00:08:01
por otros lados, aquí la podemos 00:08:04
haber liado porque este put 00:08:06
habrá sustituido el pedido 00:08:07
esperamos a confiar en que nadie nos toquetea 00:08:09
las secuencias 00:08:11
por lo menos 00:08:12
no, no está en privada 00:08:15
a ver, no, no tiene que tericete 00:08:19
porque es estática 00:08:21
vale, venga, a ver, la pongo 00:08:22
en privada, entonces solo se 00:08:25
puede toquetear desde esta 00:08:27
clase. 00:08:29
Vale, como no he hecho el resto 00:08:32
de la aplicación, puede que sea útil tocarla desde 00:08:33
cualquier otro lado, pero vale. 00:08:35
Tiene sentido que solo la toqueteemos 00:08:37
cuando insertamos. Efectivamente. 00:08:39
Solo cuando insertamos, que es cuando la generamos. 00:08:42
Pues venga, privada, muy bien. 00:08:44
Buen apunte. 00:08:46
Vale. Por lo menos pónmela 00:08:48
en privada. Pues ya te la he puesto en privada. 00:08:49
¿Ya estás contento? ¿Quieres algo más? 00:08:51
No, no quiero nada más. 00:08:52
Venga. 00:08:56
Ya hemos 00:08:58
hecho el create del 00:08:58
crud. 00:09:00
El create del crud está. 00:09:02
El consultar 00:09:05
del crud. 00:09:06
Vale, pues vamos a consultar un pedido. 00:09:08
Vale. 00:09:11
A ver, aquí de nuevo vamos a pensar. 00:09:12
Todo esto no es que haya una solución, 00:09:14
una forma de hacer lo que sea. Esta es la buena. 00:09:16
No. Vamos a hablar, 00:09:19
vamos a pensar en nuestra aplicación, 00:09:21
lo que me han pedido y vamos a decidir, tomar una decisión. 00:09:22
A ver si así sale la aplicación 00:09:25
que el tío quiere. Si no sale la aplicación que el tío 00:09:26
¿Quiénes la cambiamos? 00:09:28
Venga, vamos a pensar. 00:09:30
Cuando alguien desde la interfaz consulte el pedido, 00:09:31
¿cómo nos puede ser interesante que lo consulte? 00:09:35
Pues, hombre, por nombre, porque en los códigos no lo sabe. 00:09:38
A menos que hagamos que por, no, por descripción. 00:09:42
Vale, por descripción. 00:09:50
Sí. 00:09:52
Por descripción es difícil. 00:09:52
Es difícil. 00:09:53
no, no es difícil porque vamos a poner en la 00:09:54
interfaz un desplegable 00:09:56
con todas las descripciones 00:09:59
según tú insertas un pedido 00:10:00
se te añada el desplegable 00:10:02
así ya luego el usuario lo consulta por desplegable 00:10:04
como lo de las películas 00:10:07
porque es que si no efectivamente 00:10:08
una aplicación de consulta o tú consultas 00:10:13
al azar es una locura 00:10:15
yo iría cribando 00:10:16
primero de quién cliente es 00:10:18
claro pero de nuevo 00:10:20
vas con un cliente al azar tendrás que tener un desplegable 00:10:23
con todos tus clientes 00:10:25
pero como aquí no hemos metido cliente 00:10:26
¿verdad que no Ana? 00:10:28
¿a que no hemos metido cliente? pues entonces la consulta 00:10:30
del pedido o por código 00:10:33
o por descripción 00:10:34
entonces, hombre lo ideal sería 00:10:36
por código porque 00:10:39
la clave es código 00:10:40
entonces vamos a hacerle a luz, vamos a hacer que la interfaz 00:10:42
tenga un desplegable 00:10:45
con todos los códigos que se van generando y ya está 00:10:47
vamos a hacerlo así 00:10:49
aunque a lo mejor luego no es lo que quiere 00:10:51
el que nos ha pedido la aplicación 00:10:53
efectivamente 00:10:54
muy bien pensado, vale, pues entonces 00:10:56
vamos a hacer un desplegable 00:10:58
en la interfaz que me puede ser 00:11:01
código de descripción, código de descripción, entonces tú consultas 00:11:02
desplegando, si te salían 00:11:05
solo los códigos sería un rollo, pero si te sale el código 00:11:07
de descripción, ah quiero el pedido de 00:11:08
urgente, va, lo marco, vale 00:11:10
luego, a qué conclusión 00:11:13
llegamos, que ahora 00:11:15
este método tiene sentido 00:11:17
que la consulta, el parámetro que le llegue 00:11:19
perdón, este, sea 00:11:21
el entero 00:11:22
porque vamos a poder recoger el entero 00:11:23
del desplegable de la interfaz 00:11:26
del desplegable de la interfaz yo recojo 00:11:28
todo ese string que he puesto con un split 00:11:30
me saco el codiguito entero 00:11:32
y lo consulto 00:11:33
luego tiene ya 00:11:36
mucho sentido que yo este método de consulta 00:11:38
que voy a llamar desde el listener 00:11:40
me devuelva mi objeto 00:11:42
pedido 00:11:44
partiendo 00:11:45
del código y este código 00:11:50
me lo va a mandar el listener que lo habrá cogido 00:11:52
de mi desplegable 00:11:54
pues hombre, esto en un map 00:11:55
es que ya sabemos lo que es 00:12:00
en un map, esto así 00:12:02
hecho así un poquito 00:12:04
a lo loco 00:12:06
pues sería esto 00:12:07
en un map hecho así a lo loco sería esto de aquí 00:12:10
ahora otra cosa es que efectivamente 00:12:18
nos paremos a pensar en si esto es robusto 00:12:21
puede petar por algún lado 00:12:24
o lo de siempre, si pido ese snus va a petar 00:12:25
pero no vamos a arrastrarlo todo el rato 00:12:28
porque es un rollo 00:12:29
aparte no podemos devolver aquí false 00:12:31
podemos devolver 00:12:33
null, si devuelve null es que no he encontrado 00:12:36
el pedido 00:12:37
entonces vamos a recordar cómo funciona este get 00:12:38
este get 00:12:41
si el pedido existe 00:12:43
te lo devuelve, lógicamente 00:12:45
y si el pedido no existe 00:12:47
creo recordar que te devolvería null 00:12:49
supongo, vamos a recordarlo 00:12:51
vamos a recordar el método get 00:12:53
vamos a recordar el método get 00:12:54
como te funciona 00:12:58
el método get 00:12:59
funciona 00:13:03
devuelve el valor para esta clave 00:13:05
o null si no lo contiene 00:13:08
vale, lo que queríamos saber 00:13:10
luego 00:13:11
el método 00:13:13
nos va a devolver null 00:13:15
si no lo encuentra, pues ya está, pues el listener 00:13:18
si ve que hay un null, pues dirá 00:13:20
no existe pedido 00:13:22
pero bueno, es un poco, existirá 00:13:24
porque si lo hemos sacado del desplegable 00:13:26
el desplegable tiene los que hay 00:13:28
vale y no hay nada más 00:13:29
entonces repito puede fallar 00:13:31
y parar la aplicación si pedidos es null 00:13:34
lo evitaríamos 00:13:36
si pedidos es igual a null 00:13:37
entonces retun null 00:13:40
pondríamos si pedidos es igual a null retun null 00:13:41
en este caso no retun 00:13:44
false lógicamente 00:13:48
vale si el array de pedidos 00:13:50
no existe si el hasmat de pedidos no existe 00:13:56
pues devuelveme un pedido null 00:13:58
no lo ha encontrado lo podemos dejar así 00:13:59
no, si el código no existe 00:14:02
también me devuelve null, me puede devolver null 00:14:06
por dos cosas, porque el hash map 00:14:08
no exista y porque el código no 00:14:10
existe, en cuyo caso el get ya me devuelve null 00:14:12
del desplegable, en este caso 00:14:14
va a existir, si he llamado 00:14:18
a getpedido desde el listener, pero si he llamado a getpedido 00:14:20
desde otra parte de la aplicación 00:14:23
pasándole un código que no exista 00:14:24
bueno, es lo mismo que hemos hecho 00:14:26
aquí, vale 00:14:31
aquí lo único es que 00:14:33
este método 00:14:35
me está avisando de la misma manera 00:14:36
de dos situaciones distintas 00:14:39
tanto si el map no existe 00:14:40
como si el map existe 00:14:43
y no está el pedido 00:14:45
de dos situaciones distintas 00:14:46
me está avisando de la misma manera 00:14:48
devolviendo un null 00:14:50
¿me importa eso? 00:14:52
pues no, no me importa 00:14:55
no me importa 00:14:57
si me... 00:14:59
claro, eso, no funca 00:15:00
no he encontrado el pedido, me da igual que sea 00:15:02
porque la caja no existe o porque no está 00:15:04
en la caja, no entra el pedido 00:15:06
claro, si yo estoy en una situación en la que 00:15:08
tuviera que distinguir, aquí ya sí 00:15:10
que sí o sí tengo que poner la excepción 00:15:12
porque el valor de retorno 00:15:14
nul está usado 00:15:16
para la caja existe pero no está el pedido 00:15:18
con lo cual para la otra 00:15:20
situación, que es la situación la caja 00:15:22
ni existe 00:15:24
tengo que avisar en tu dejo una excepción 00:15:25
¿verdad? 00:15:28
Sí, estoy hablando muy 00:15:29
poniéndolo muy en general porque no sé quién va a llamar 00:15:33
a esto, si mi aplicación la van a toquetear 00:15:35
¿Vale? Estoy hablando 00:15:37
en general de procedimientos 00:15:39
¿Vale? De aspectos muy 00:15:40
generales ¿Vale? 00:15:43
Lo importante es que nos quedemos con eso 00:15:45
que la realimentación que ofrece 00:15:47
el método, la realimentación que ofrece 00:15:49
puede ser, por supuesto 00:15:51
por consola, con un SISO 00:15:53
pero por consola tiene la utilidad que tiene 00:15:55
Si mi aplicación es con interfaz gráfica, ninguna. 00:15:57
Y si no lo es, también poca, porque tiene que haber un tío 00:16:00
ahí mirando. 00:16:01
Desde luego, al código, la realimentación por consola no le 00:16:03
vale para nada. 00:16:05
Vale, luego nos olvidamos de la realimentación. 00:16:06
Las otras dos vías de la alimentación son por el valor 00:16:09
de retorno y porque lance una excepción. 00:16:11
Si yo puedo, a través del valor de retorno, 00:16:14
avisar, dar la realimentación que necesito, maravilloso. 00:16:17
En este caso, en este caso, puedo. 00:16:21
porque ese null 00:16:24
me va a avisar tanto de si la caja 00:16:25
no existe como si existe pero no tiene el código 00:16:28
me vale, pero si yo quiero 00:16:30
realimentar de dos cosas distintas 00:16:32
o incluso de muchas cosas distintas 00:16:34
tengo que empezar a poner excepciones 00:16:36
¿vale? y que cada excepción 00:16:39
me avise de una cosa distinta 00:16:40
tendré que crear el objeto excepción 00:16:42
y hacer aquí el throw 00:16:44
cuando pase eso, y con excepciones 00:16:46
puedo yo realimentar de mil 00:16:48
situaciones diferentes 00:16:50
con el valor de retorno solo de una 00:16:51
Bueno, si yo pongo aquí un throw 00:16:54
cualquier otra excepción, el que lo 00:17:02
me está usando me dirá, cuidado que este método 00:17:04
te puede lanzar la excepción, hoy llueve 00:17:06
y dirás, vale, pero hoy llueve 00:17:08
no tiene que ver con que no exista el pedido 00:17:10
entonces, hombre, no es una buena manera, pero sí 00:17:12
te estaría avisando de que algo ha pasado 00:17:14
pero de lo que 00:17:16
ha pasado no sabes, entonces 00:17:18
tal ahora tú de capturarla, ¿cómo la capturas? 00:17:20
¿sacando el paraguas? Pues no 00:17:22
lo que no era la lluvia lo que me importaba 00:17:24
vale 00:17:26
nunca ahorres tiempo en la vida 00:17:27
vale 00:17:32
ya tenemos la consulta por código 00:17:34
actualizar un pedido 00:17:36
actualizar un pedido 00:17:37
sería un método 00:17:40
ahora de nuevo pensamos cuando puede querer 00:17:42
el usuario de mi aplicación al que yo le estoy 00:17:44
vendiendo es actualizar un pedido en que contexto 00:17:46
bueno pues 00:17:48
por ejemplo vamos a 00:17:50
Por ejemplo 00:17:51
Ya, uh, no, pero esa es muy 00:17:55
Sí, añadirte un boli 00:17:58
Vale, entonces podemos hacer 00:18:00
O bien actualizar pedido 00:18:02
O bien, porque haya cambiado la descripción 00:18:04
Pero va, vamos a dejar esa 00:18:05
O bien añadir un producto nuevo, que puede tener más interés 00:18:07
¿Vale? 00:18:09
O quitar un producto 00:18:13
Ya, pero es que entonces el audaz de producto 00:18:14
Los parámetros que va a recibir 00:18:16
Tenemos que hacer varios 00:18:18
pero le obligas al listener 00:18:20
o al método que sea a pasar la lista 00:18:24
vamos a hacer una versión más sencilla 00:18:25
que no complique la aplicación 00:18:28
si, si, si, yo creo que debería 00:18:29
a ver 00:18:32
los de atrás 00:18:34
lo están siguiendo 00:18:36
vale 00:18:38
pues venga, vamos a pensar 00:18:41
a ver 00:18:43
vamos a pensar 00:18:46
esto es una decisión que tomamos 00:18:49
no es que tenga que ser así, una decisión 00:18:51
acorde con el que nos ha pedido 00:18:53
la aplicación, vamos a sentarnos 00:18:55
a decidir, cuando tú actualices 00:18:57
un pedido, ¿a qué te refieres? 00:18:59
y él nos va a decir, solamente 00:19:02
añadirle un producto, quitarle nunca jamás 00:19:03
porque hombre, vaya pérdida de dinero 00:19:06
¿vale? entonces ya nos hemos sentado 00:19:07
con él, nos ha dicho, para mí actualizar un 00:19:09
pedido va a ser añadirle un producto 00:19:11
¿vale? pues como ya nos ha dicho eso 00:19:13
ahora ya hacemos el método, ya tenemos la información 00:19:15
pues venga, el método de actualizar 00:19:18
tiene sentido 00:19:20
que sea, vamos a ponerle 00:19:24
por ahora void, bueno 00:19:26
y luego ya cambiamos 00:19:27
la realimentación a lo que queramos 00:19:29
update product 00:19:31
vale, que pedido 00:19:33
perdón, update pedido 00:19:37
perdón, perdón, perdón 00:19:39
vale, datos que necesita el método 00:19:40
pedido actualizar 00:19:43
su código 00:19:45
el código de pedido actualizar 00:19:47
y el producto nuevo 00:19:51
porque actualizar pedido 00:19:53
hemos quedado que solo es para esto 00:19:57
solo es para eso, para nada más 00:19:59
si no tendríamos que hacer más métodos 00:20:01
o un método con diferentes parámetros y que 00:20:05
él distinga dentro los que sean y los que no 00:20:07
y hacerlo, muchas opciones 00:20:09
que no queremos 00:20:10
vale, bueno, pues entonces que tenemos que hacer 00:20:12
esto ya lo sabréis 00:20:15
hacer, ¿no? sacar el pedido con ese código 00:20:17
al pedido con ese código 00:20:19
añadirle el producto 00:20:21
y ahora ya volver a meter ese 00:20:22
producto en el map 00:20:25
vale, pues vamos a sacar el 00:20:27
vamos a sacar 00:20:29
el pedido con ese código 00:20:31
mi pedido 00:20:33
p es 00:20:35
el pedido con este código 00:20:36
que raro que no me ofrezca 00:20:41
código ahí, bueno 00:20:44
sí, pero lo tiene arriba y luego 00:20:45
encima tiene un entero, que raro que no me lo haya 00:20:53
ofrecido, vale, tengo el pedido 00:20:55
ahora, a su lista 00:20:57
de productos 00:20:59
a esta lista 00:21:01
le vamos a añadir el producto 00:21:02
nuevo, vale 00:21:05
y ahora 00:21:08
necesitaríamos 00:21:15
volver a poner el producto 00:21:20
en el map 00:21:22
esto es necesario 00:21:23
esta sentencia 00:21:26
es necesaria 00:21:34
esta 00:21:36
P es la referencia 00:21:40
no he cambiado la referencia 00:21:51
esto, el map 00:21:52
tiene la clave y el objeto 00:21:56
¿y un objeto qué es? su referencia 00:21:59
pues yo a través de la referencia he modificado lo que contiene 00:22:01
pero la referencia o lo que es lo mismo el objeto 00:22:05
es el mismo, no ha cambiado 00:22:08
claro, con lo cual esta sentencia 00:22:09
no es necesaria 00:22:12
otra cosa es que yo cambiara 00:22:13
¿vale? el objeto 00:22:16
y fuera otro objeto con otra referencia 00:22:18
¿vale? 00:22:21
entonces sí 00:22:23
vale, pues entonces ahora de nuevo 00:22:23
realimentación, este método necesita realimentación 00:22:31
perdón 00:22:34
bueno, a ver 00:22:35
pues si algo falla, podemos avisar con un boolean 00:22:37
lo suyo sería poner el boolean 00:22:40
¿qué puede fallar? de nuevo 00:22:42
que pedido sea null 00:22:43
o puede fallar 00:22:44
que esto sea null 00:22:46
porque no tenga productos 00:22:48
pero hombre, eso no va a ser null nunca 00:22:51
porque yo aquí ya la inicializo como vacío 00:22:53
entonces 00:22:55
perdón, la inicializo como un array list nuevo 00:22:57
entonces que 00:22:59
esto sea 00:23:01
que pedido sea null 00:23:03
o bueno, podemos arrastrarlo como siempre 00:23:04
y devolver, pero vamos a dejar 00:23:07
venga, para que no parezca 00:23:09
que luego 00:23:11
lo miráis 00:23:12
si es que lo miráis y decís 00:23:15
aquí porque lo pone y aquí porque no 00:23:16
y no os acordáis de lo que hemos dicho 00:23:18
pues entonces venga lo ponemos 00:23:20
y así no entráis en colisión 00:23:22
vale 00:23:23
si la caja está vacía me devuelve 00:23:27
falso porque entonces no habrá podido modificarlo 00:23:35
y si la caja no está vacía 00:23:37
aquí 00:23:41
hay otro fallo 00:23:44
importante 00:23:47
Que el tío me haya dado un código que no existe 00:23:47
Si me ha dado un código que no existe 00:23:50
Esto es null 00:23:52
Y si esto es null, aquí hay un pedazo null pointer exception 00:23:53
Claro, entonces 00:23:57
Si p 00:23:59
Es igual a null 00:24:00
Me voy de aquí 00:24:02
Corriendo, porque si no me sale 00:24:04
Un null pointer exception impresionante 00:24:06
Y si p no es null 00:24:09
Ya lo actualizo 00:24:11
¿Vale? Entonces este método me va a devolver 00:24:12
False si no ha podido hacer la actualización 00:24:15
por la razón que sea. Porque no hay caja 00:24:16
de pedidos. Porque había caja, pero el pedido 00:24:18
no estaba. Si me devuelve nulo 00:24:20
es que esto no se ha hecho. 00:24:22
Y si no me devuelve nulo es que se ha hecho. 00:24:24
Perdón, true o false. 00:24:26
Perdón, perdón. 00:24:28
¿Por qué? 00:24:30
¿Qué he hecho? 00:24:32
No, porque... 00:24:33
Solo uno. 00:24:34
Buf, vais a ver 00:24:38
métodos con 2.000 millones de retunes. 00:24:39
Que no digo que estén bien. 00:24:41
Que no sea una práctica de programación buena. 00:24:43
estos son break, poner break es a mogollón 00:24:45
poner break es a mogollón no es una buena práctica 00:24:46
de programación, es ir saliendo con break 00:24:49
no hay nada más 00:24:51
opuesto a la programación estructurada que los break 00:24:53
porque desestructura 00:24:55
tú puedes salir por cualquier lado, la idea de la programación estructurada 00:24:57
es que tú tengas un camino en el que entras por un lado 00:24:59
y sales por el otro, punto pelota 00:25:01
y aquí estamos saliendo 00:25:03
en absoluto 00:25:04
nos queremos muchísimo 00:25:07
no me peleo nada 00:25:08
bueno pues 00:25:09
en sus exámenes le hacéis caso 00:25:16
ella hace lo mismo 00:25:19
en cualquier caso yo no 00:25:19
contradigo lo que ella dice 00:25:22
lo que ella dice está correcto 00:25:24
la programación estructurada 00:25:26
cuanto menos break y retún tenga mejor 00:25:27
pero luego uno vive y sobrevive 00:25:29
y os vais a encontrar de todo 00:25:32
hacer esto sin retornar 00:25:36
de alguna manera 00:25:37
hombre pues lo natural sería 00:25:39
aquí un boolean 00:25:42
result 00:25:44
igual a lo que fuera 00:25:45
a true 00:25:47
y aquí en lugar de 00:25:48
return 00:25:52
result 00:25:52
result igual false 00:25:54
y aquí abajo lo mismo 00:25:58
result 00:25:59
igual false 00:26:02
y ahora aquí return result 00:26:04
y punto pelota 00:26:05
esta es la forma bonita 00:26:06
¿vale? 00:26:09
tú tienes un único punto de salida 00:26:11
este es tu punto de salida 00:26:13
¿pero tienes que poner el otro dentro de un it return? 00:26:14
¿no? 00:26:17
o sea 00:26:20
¿como que no sales? 00:26:20
yo salgo por return 00:26:24
y puede ocurrir dos cosas, que result sea true 00:26:25
porque todo ha ido bien 00:26:28
o que sea false porque ha ocurrido una de estas dos 00:26:29
me refiero a que si 00:26:31
igual se va a ejecutar 00:26:32
Claro, se va a ejecutar igual, no es como antes. 00:26:34
Ah, vale, vale, vale, que tengo que meter esto en... 00:26:36
Sí, sí, sí, claro, sí, sí, sí, o meterlo en los dos de arriba, sí, sí, sí, sí, sí, claro. 00:26:39
Si result es... 00:26:45
Si result, entonces ya está. 00:26:51
Y ahora el pedido P también, el result. 00:26:55
¿Qué pedido P? 00:26:59
El de arriba, pedido P, igual pedido después. 00:27:01
Ah, este pedido de aquí 00:27:04
que no lo veía, sí 00:27:07
Vale, conclusión 00:27:08
y como aquí estoy declarando 00:27:12
encima 00:27:15
pues encima tengo que pedir aquí 00:27:15
una llave 00:27:20
porque estoy haciendo aquí la declaración 00:27:21
entonces tengo que 00:27:27
vale, a ver 00:27:28
claro, con lo cual 00:27:30
esto 00:27:32
claro, a ver, tendría que cambiar 00:27:33
el código para que quedara un poco más bonito 00:27:37
porque así ya es 00:27:38
entonces 00:27:40
vale, esto está más estructurado 00:27:43
tendríamos que hacer algún 00:27:48
podríamos hacer algún arreglito con estos 00:27:50
para que no quedaran tantos 00:27:52
habría que hacer 00:27:53
más feo, pero 00:27:55
lo otro, y de hecho 00:27:58
Python 00:27:59
que está orientado a facilitar 00:28:01
la vida y que sea todo muy sencillo 00:28:04
tan sencillo que es que eso 00:28:06
es un desastre de lenguaje 00:28:08
porque ahí ni se declara nada 00:28:10
ni hay tipos de datos, que un tipo de repente 00:28:12
metes otra cosa, él se adapta a lo que sea 00:28:14
todo, todo, o sea es terrorífico 00:28:16
entonces como te deja hacer todo 00:28:18
entonces está muy bien, te deja hacer 00:28:20
todo, él va decidiendo 00:28:22
que burrada has hecho, yo te lo apaño 00:28:23
en fin, es un desastre, para aplicaciones 00:28:25
no es un desastre, para aplicaciones 00:28:28
en realidad empresariales, por eso sobre todo 00:28:30
se hacen con Java, porque al ser un poquito 00:28:32
más rígido, pues es más difícil 00:28:34
que la cagues. Bueno, pues en Python 00:28:36
que ha sido una tendencia 00:28:38
hacia facilitar 00:28:41
en Python, sin embargo 00:28:42
todo se hace con break, prácticamente 00:28:44
o sea, ha vuelto el break a nuestras vidas 00:28:46
porque facilita 00:28:48
un poquito, pero en origen 00:28:50
en origen se desterró cuando 00:28:52
se inició la programación estructurada 00:28:54
pero es cierto que, jolín 00:28:56
Me queda un poco de pereza, ¿no? 00:28:58
Evitar los return y los break. 00:28:59
Así que os vais a encontrar de todo. 00:29:02
Pero lo que os dice Rosa es cierto. 00:29:04
Luego vosotros tenéis que hacer las cosas 00:29:06
como creáis que vais a ganar más dinero. 00:29:08
Vale. 00:29:12
Entonces, yo, de hecho, 00:29:16
no se lo digáis a Rosa, 00:29:18
pero lo voy a dejar como lo tenía 00:29:20
porque es que tantas líneas 00:29:22
me están dando ansiedad. 00:29:24
vale, yo lo voy a dejar así 00:29:28
pero es feo 00:29:35
pero es más fácil de ver 00:29:36
vale 00:29:39
y chat GPT 00:29:40
chat GPT programa así 00:29:43
chat GPT pasa la aplicación 00:29:45
estructurada completamente 00:29:47
chat GPT todo lo que puede hacer con 00:29:48
break y con return lo hace con 00:29:51
break y return 00:29:53
bueno 00:29:54
Vale, pues ya hemos actualizado 00:29:56
Preguntárselo a ella 00:29:59
Qué opinión tiene de mí 00:30:03
Y preguntadme a mí 00:30:04
Qué opinión tengo de ella 00:30:06
La mía de ella es buenísima 00:30:07
Y estoy convencida que la suya de mí también 00:30:09
Venga 00:30:11
Bueno, pues 00:30:13
Nos llevamos estupendamente 00:30:18
Porque es una persona estupenda 00:30:19
Es que realmente no hay nada que 00:30:21
Bueno, venga, seguimos 00:30:22
borrar 00:30:26
además si no fuera así 00:30:28
no lo diría porque estoy grabando 00:30:30
pero 00:30:32
pero es así 00:30:33
venga, terminamos con el borrado 00:30:36
que no, no, no, es completamente en serio 00:30:39
es completamente en serio 00:30:42
borrar 00:30:45
borrar un pedido, borrar un pedido es lo más fácil 00:30:46
o el tío quiere borrar un pedido 00:30:48
pues ya está, seleccionará 00:30:51
en su desplegable 00:30:53
y el que seleccione borrado 00:30:53
luego por código 00:30:56
este sí que es lo más fácil 00:30:57
del mundo 00:31:05
porque me he equivocado 00:31:05
para los errores de los demás 00:31:08
estáis muy despiertos 00:31:13
vale 00:31:14
pues borrar un pedido pues ya está 00:31:17
es que luego nos dice 00:31:19
¿qué voy a usar en este código? 00:31:20
vale 00:31:25
pues remove 00:31:25
código 00:31:27
y anda 00:31:28
para reutilizar, para utilizar el boolean 00:31:31
este famoso 00:31:33
pues hacemos esto de aquí 00:31:34
ala 00:31:37
ya está 00:31:41
pedidos remove 00:31:47
a ver, puede ocurrir que no existiera 00:31:50
si no existiera el remove 00:31:52
como funciona, que me devuelve remove 00:31:53
si no existe el código, vamos a verlo 00:31:56
remove 00:31:58
devuelve la clave del que ha borrado 00:32:00
devuelve null 00:32:04
si no contenía la clave 00:32:12
vale, pues entonces 00:32:14
le podemos hacer también 00:32:15
if pedidos remove código 00:32:17
es igual a null 00:32:25
es que no lo pudo borrar porque me devolvió null 00:32:27
entonces en ese caso 00:32:29
un tercer return falso 00:32:31
y si llegamos hasta aquí abajo, retontro. 00:32:33
Sería interesante 00:32:38
en cuanto nos vuelva a venir algún chaval 00:32:40
de estos que programa por ahí 00:32:43
que está trabajando en una empresa 00:32:45
programando y haciendo proyectos 00:32:48
preguntarle qué se encuentra él 00:32:49
y qué es lo que suelen hacer. 00:32:52
Vale, venga, pues ya está. 00:32:56
Tenemos todas estas tareas 00:32:58
con estos datos. 00:33:01
Y ahora ya habrá una interfaz 00:33:04
que llame a los 00:33:06
métodos, nos 00:33:08
falta aquí en estos métodos ponerle un modificador 00:33:10
maravilloso o no 00:33:12
no nos falta esto 00:33:13
claro sería 00:33:16
lo suyo ponerle un static a estos métodos 00:33:18
para poder llamarlo luego cómodamente 00:33:20
desde el listener 00:33:22
nos falta aquí unos static 00:33:23
increíbles 00:33:25
delete esta 00:33:27
con su static 00:33:34
Claro, pero a la vez lo estoy ejecutando. 00:33:36
Claro, claro. 00:33:48
Estoy haciendo la sentencia y además estoy recogiendo el valor de retorno para compararlo con el null. 00:33:50
Vale. 00:33:56
Pues, claro, porque está en la única variable con la que trabajan es esta que es estática 00:33:58
y esta que es estática, solo trabajan con esa 00:34:05
entonces, y ahora ya nos podemos 00:34:08
plantear hacer la aplicación que gestiona y usa 00:34:10
estas cosas, que puede ser que nos haga falta 00:34:12
otros métodos útiles, pues los metemos 00:34:13
lo que sea, pero estos yo los ponía como 00:34:15
ejemplo de los métodos que siempre se recogen 00:34:18
en una clase de acceso a datos 00:34:19
que son estos de aquí 00:34:22
a través, bueno 00:34:23
con otra estructura normalmente y otras cosas 00:34:26
pero bueno, la idea es la misma 00:34:27
lo que hay 00:34:28
lo que 00:34:32
sí, lo que hay es 00:34:34
unas herramientas estupendas 00:34:35
unos frameworks, unas clases que si tú configuras 00:34:37
le pones 00:34:40
insert pedido 00:34:43
se adapta a tu base de datos 00:34:44
te genera el código y te hace absolutamente todo 00:34:46
con lo cual tú lo tienes que programar 00:34:48
eso sí, tienes que entender perfectamente 00:34:49
bien cómo funcionan y saber configurarlas 00:34:52
porque si no estás perdido 00:34:54
y chat GPT en ese caso 00:34:57
no es de mucha ayuda, porque ahí sí que dependemos 00:35:00
completamente de las versiones 00:35:02
con las que estemos trabajando 00:35:04
y ahí sí que se vuelve loco 00:35:05
con el tema de las versiones, de las dependencias 00:35:06
de clases, de no sé qué 00:35:08
son muchas cosas 00:35:10
claro, no tiene todas las actualizaciones 00:35:12
y llega un momento 00:35:18
en que ya te dice 00:35:21
mira, deja de preguntarme porque es que no te lo voy a conseguir 00:35:22
alguna vez responde eso 00:35:24
sí, burradas sí 00:35:27
luego te pido perdón 00:35:30
pero incluso hay veces que te dicen 00:35:32
mira 00:35:33
Sí, pero hay veces que reconoce 00:35:34
Que no te va a poder ayudar 00:35:39
Y te dice, mira, realmente es que estoy perdido con esto 00:35:39
Porque le falta información 00:35:42
Claro, normal, le faltan los datos 00:35:44
Con lo cual el año que viene 00:35:45
No vais a poder usarlo 00:35:48
Para todo, solo para algunas cosas 00:35:49
Gemini 00:35:51
Otro, ¿qué me has dicho? 00:35:55
Pues ahora ya 00:35:58
Ahora ya tendríamos que hacer 00:36:01
la vista de esta aplicación que es la interfaz 00:36:04
y ahora ya esto es un rollo porque 00:36:06
habría que decidir, ¿qué componentes 00:36:07
queremos? Entonces, pues 00:36:09
para insertar, pues campos de texto 00:36:11
para descripción y no sé qué, vale 00:36:13
para añadir 00:36:15
producto, ¿tenemos un añadir producto a pedido? 00:36:17
Pues a través 00:36:21
de UDATE pedido, cada vez que 00:36:21
le damos a UDATE pedido, le estamos 00:36:23
añadiendo producto nuevo, entonces nuestra 00:36:25
interfaz, ¿qué va a necesitar? 00:36:28
Sí, las áreas de texto 00:36:31
que hagan falta, un desplegable 00:36:33
para mostrar todos 00:36:36
los códigos según vas haciendo los 00:36:37
insert, pues ahora entonces 00:36:39
ahora ya, este 00:36:41
es vuestro trabajo de arranque ahora mismo 00:36:43
hacer el frame 00:36:45
decidir que componentes 00:36:47
necesitáis para 00:36:50
insertar los datos, mostrar 00:36:51
los datos, recuperarlos 00:36:54
¿vale? 00:36:56
y actualizarlos que en ese caso 00:36:58
añadir el, entonces 00:36:59
por ejemplo, una forma de organizarlo 00:37:01
en este caso quizá no hace tanta falta 00:37:04
porque no son muchos datos 00:37:06
los que tenemos, pero una forma 00:37:08
de organizarlo, podríamos hacerlo con paneles tabulados 00:37:10
con diferentes paneles, no ponerlo todo 00:37:12
mogollón en un panel, por ejemplo 00:37:14
vamos a hacernos la vista de esta aplicación 00:37:16
pues nos hacemos 00:37:18
un frame 00:37:19
nos hacemos un 00:37:20
yo que estoy haciendo 00:37:34
vale 00:37:37
un frame 00:37:41
app pedidos 00:37:42
vale 00:37:45
pues nuestro frame 00:37:52
que es este 00:37:54
vale, pues podríamos ya ponerle una barra de menús arriba 00:37:55
pero esa la vamos a hacer 00:38:03
cuando hagamos una aplicación 00:38:04
pues cuando hagamos un procesador de texto, por ejemplo 00:38:07
que podamos hacer archivos para cargarlos 00:38:08
para no se que, entonces lo dejamos para ahí 00:38:10
podemos meter 00:38:11
para que tengáis algún componente más 00:38:12
no vamos a perder mucho el tiempo en esto 00:38:16
pues por ejemplo paneles tabulados 00:38:17
yo tengo insertar 00:38:19
modificar, pues poner cada cosa 00:38:22
en un panel distinto y así no tengo que 00:38:24
tener todos los datos a mogollón, que el usuario 00:38:26
igual se vuelve loco. Vale, pues 00:38:28
¿cómo hacer diferentes paneles 00:38:30
que cada uno tenga asociado a una pestañita 00:38:32
o te mueves uno a otro? 00:38:34
Pues 00:38:36
Sí, hombre 00:38:37
sale un montón de aplicaciones 00:38:40
por ejemplo, aquí 00:38:41
me refiero a esto 00:38:43
por ejemplo, imagínate que hacemos esto de aquí 00:38:45
a esto 00:38:51
tú tienes aquí diferentes 00:38:56
paneles, cada panel se ocupa 00:38:58
de una cosa y esto podría 00:39:00
estar todo metido en lo mismo, pero sería más 00:39:01
complicado para el usuario, mejor si cada panel 00:39:03
tiene aquí una pestañita 00:39:06
distinta y tú vas cambiando donde lo quieras hacer 00:39:08
pues a esto me refiero 00:39:10
entonces tendríamos un panel para insertar, otro para 00:39:11
hacer consultas, otro para hacer, entonces si la aplicación 00:39:13
va creciendo y se va complicando lo de insertar 00:39:16
o lo de consultar se va 00:39:18
complicando porque puedes consultar por varios parámetros 00:39:19
pues así no vas a añadir 00:39:22
todo al mismo panel, lo añades a paneles separados 00:39:23
cada parte, ¿vale? 00:39:25
Bueno, pues esta 00:39:27
chorrada de los paneles. 00:39:28
Pues bueno, primero a nuestro panel gordote 00:39:34
le ponemos el 00:39:37
absoluto, que no se nos olvida. 00:39:38
Y ahora, 00:39:42
tiene que haber 00:39:43
un superpanel 00:39:45
que es el que luego acoge 00:39:46
los paneles pequeñitos. 00:39:49
Y ese superpanel es el 00:39:50
JTABETPAN, es ese de ahí. 00:39:52
Pues venga, 00:39:55
J-Tablet panel. 00:39:57
Lo hacéis, pues, lo adaptáis al tamaño que queráis. 00:40:04
El panel grandote. 00:40:08
J-Tablet panel. 00:40:10
Es el. 00:40:11
En containers. 00:40:12
Está en containers, no en componentes. 00:40:14
En contenedores está. 00:40:16
¿Vale? 00:40:18
Sí te sale en containers. 00:40:20
En containers está el cuarto. 00:40:22
Bueno. 00:40:27
No. Lo hacéis grande 00:40:28
que sabéis. 00:40:30
No tengo ni idea. 00:40:31
Pues tira de ahí. 00:40:34
Vale. 00:40:37
Y ahora ya, este todavía no es 00:40:38
un panel para coger componentes. Ahora a este 00:40:40
ya le ponemos tantos paneles como queramos. 00:40:42
Pues ahora ya vamos arrastrando tantos paneles 00:40:44
como queramos. Por ejemplo, cogemos un Jpanel. 00:40:46
Un Jpanel es el panel básico. 00:40:48
Lo cogemos y lo 00:40:50
arrastramos ahí hasta donde se nos pone 00:40:52
la rayita roja gorda. 00:40:54
¿Vale? 00:40:57
Y ya nos ha aparecido un nuevo panel. 00:40:58
Claro, veis, tiene que aparecer debajo de este. 00:41:01
Aquí lo natural sería que le cambiéis, lógicamente, 00:41:05
el nombre de la pestaña, que queda muy fea. 00:41:09
Pues, os vais a propiedades del panel. 00:41:12
Le podríamos cambiar el nombre de la variable para que fuera 00:41:15
más cómodo. 00:41:17
Panel insertar, por ejemplo. 00:41:18
Y ahora, abajo en propiedades, pues, 00:41:20
el valor de la pestañita en tab properties. 00:41:23
Pues la pestañita en lugar de new tab, pues insertar, por ejemplo. 00:41:28
¡Hala! 00:41:37
Despliega tab en properties del panel. 00:41:39
Y ya está. 00:41:46
Y ahora, otro panel más. 00:41:47
Lo arrastramos al panel gordote. 00:41:49
Tenemos que tener seleccionado al gordote. 00:41:51
Lo arrastramos al gordote. 00:41:53
¡Hala! 00:41:57
Hasta que nos aparezca la raya del gordote 00:41:57
Ya tenemos otro 00:42:00
Panel 00:42:02
Borrar 00:42:08
Vale, le cambiamos la pestaña 00:42:13
Eliminar 00:42:23
Vale 00:42:32
Las podéis cambiar el orden 00:42:33
Las movéis si queréis que aparezca en otro orden 00:42:36
ponemos el de 00:42:38
modificar 00:42:44
espérate, este no me lo ha puesto bien 00:42:46
jPanel 00:42:48
ay, joder 00:42:50
si no tenéis seleccionado el 00:42:51
panelado, no sé 00:42:54
joder, que no quiero esto 00:42:56
vale, a ver 00:42:59
ahí 00:43:01
arriba 00:43:02
arriba 00:43:03
a la derecha del guión 00:43:04
pero y porque aquí no me lo 00:43:06
antes juré, vale 00:43:08
vale 00:43:10
pues este va a ser 00:43:12
el de 00:43:14
actualizar, añadiendo un pedido 00:43:16
nuevo, en este caso 00:43:18
es para lo único que usábamos 00:43:20
actualizar, para añadirle un pedido nuevo 00:43:24
eso nos facilita 00:43:26
que el insertar sea solamente por descripción 00:43:28
insertamos un pedido por descripción solamente 00:43:30
si hubiéramos añadido el cliente 00:43:32
los clientes que han hecho un pedido 00:43:36
pues claro, aquí ya se complicaría con un montón de controles 00:43:37
y de cosas 00:43:40
pero hemos hecho la versión corta 00:43:41
que tampoco es tan corta 00:43:43
pero 00:43:47
vale, y esta era 00:43:48
actualizar 00:43:51
y nos falta consultar 00:43:53
vale, aquí 00:43:59
lo único es 00:44:20
que 00:44:22
tanto eliminar como actualizar 00:44:23
como consultar, como se van a hacer por código 00:44:27
tienen que tener 00:44:29
el desplegable con todos 00:44:31
entonces podemos hacer un desplegable 00:44:33
en cada panel 00:44:36
uno aquí, otro aquí, otro aquí 00:44:36
en cada panel un desplegable 00:44:40
o a lo mejor 00:44:41
esto ya va en gusto 00:44:44
si uno lo quiere hacer, pues pone el desplegable 00:44:45
fuera 00:44:47
ponemos el desplegable aquí fuera 00:44:48
mucho mejor y así nos replicamos 00:44:51
ese desplegable en los tres paneles 00:44:54
entonces pues aquí lo ideal es que 00:44:55
hubiera un combo box 00:44:57
o podéis explorar 00:44:59
un JList 00:45:03
un JList 00:45:04
es el componente este 00:45:06
que es como un área de texto pero que te 00:45:08
permite 00:45:10
bueno 00:45:10
es otra forma de 00:45:15
bueno el JList tiene un modelo 00:45:17
que tú, a ver, no es que haya muchas diferencias 00:45:22
pero 00:45:24
es más habitual y es más 00:45:25
cómodo de manejar 00:45:28
sería lo ideal que lo averiguarais 00:45:30
que lo investigarais con un JList 00:45:32
A ver si, por ejemplo, un JLIS, el Eclipse seguro que usa un JLIS en alguna de las cosas que tiene por aquí. 00:45:33
A ver si yo pongo aquí propiedades, por ejemplo. 00:45:42
Es un JLIS de la parte de la mejor de la vida del mundo. 00:45:51
Espera, bueno, vamos a buscar la imagen en internet y ya está. 00:45:55
Jolín con la Wi-Fi nueva. 00:46:13
Vale. 00:46:32
JList 00:46:36
Java 00:46:37
Swing 00:46:38
Vale, el JList 00:46:39
es este componente 00:46:43
en lugar de 00:46:46
aparecerte en un desplegable, te aparece en un área 00:46:48
como esta 00:46:50
¿Vale? 00:46:50
Claro, un JList es esto 00:46:54
y tú seleccionas 00:46:56
aquí el que quieres 00:46:58
y también tienes su evento asociado 00:46:59
o puedes, ¿vale? 00:47:02
Tú seleccionas y luego le das al botoncito 00:47:03
Quiero borrar este 00:47:05
O quiero eliminar 00:47:06
Pues o bien en un combo box 00:47:08
O bien en un JLIS aparecerán todos los IDs 00:47:10
Con la descripción 00:47:13
¿Vale? 00:47:14
Entonces esta aplicación 00:47:17
Que era para agregar un nombre 00:47:19
Pues ese nombre se podía haber agregado en combo box 00:47:20
Y ya está, y luego seleccionas del combo box 00:47:23
Y la diferencia 00:47:25
Es que el JLIS lo ves todo como más claro 00:47:27
Porque es que lo tienes ahí abierto y lo ves todo 00:47:29
El combo box tienes que desplegarlo 00:47:31
¿Y el combo box cómo puedes hacerlo? 00:47:32
A ver, en el combo box lo ideal es que le añades 00:47:34
solamente los string y ya está, no lo cargues 00:47:47
con todo el objeto, claro 00:47:48
al combo box le añades solo el string que tú has construido 00:47:50
en base al código y la descripción 00:47:53
ya está, entonces 00:47:54
hacedlo para probar este 00:47:56
componente que es quizá más habitual 00:47:58
que el desplegable en las aplicaciones 00:48:00
pues un JList, vale, entonces 00:48:03
Entonces uno de estos tiene que aparecer aquí, un JList, aquí queremos un JList en el que 00:48:04
vayan apareciendo todos los pedidos que vamos insertando. 00:48:35
Ese JList automáticamente lleva asociado a una barrita. 00:48:40
Entonces, si se salen del espacio, 00:48:44
va a aparecer esa barrita para moverte por él. 00:48:45
Entonces, cuando le demos a eliminar, 00:48:48
seleccionaremos el este. 00:48:50
Lo que pasa es que ahora se nos ha quedado el panel de eliminar 00:48:52
y consultar, se nos han quedado vacíos, 00:48:54
porque no hay nada que poner en él. 00:48:57
Porque eliminar, seleccionaremos esto, 00:48:59
el botón, como mucho, botón eliminar, nada más. 00:49:01
Y consultar, bueno, consultar tendrá el área de texto 00:49:04
para la descripción y para los pedidos y para todo eso. 00:49:08
Para la lista de productos. 00:49:12
La lista de productos y el botoncito 00:49:12
de consultar. 00:49:14
Eliminar es el que se nos ha quedado con un botón solo. 00:49:16
Si tenemos aquí... 00:49:19
Se podría poner 00:49:20
eliminar aquí abajo, por ejemplo. 00:49:24
Sí, podemos quitar este panel. 00:49:28
El panel de eliminar, efectivamente. 00:49:30
El panel borrar 00:49:32
fuera. 00:49:34
Este panel... 00:49:36
No me deja borrarlo desde aquí. 00:49:38
suprimir 00:49:44
no me deja borrarlo 00:49:45
ah, que se me ha colgado 00:49:48
el builder es un auto 00:49:53
bueno, pero sabéis la idea 00:49:56
debajo del JList 00:49:59
debajo del JList 00:50:02
ponéis un propio botón 00:50:04
eliminar debajo del JList 00:50:06
y que eliminar sea con este botón 00:50:07
eliminar y ya está 00:50:09
y los paneles sean solamente para insertar 00:50:11
actualizar y consultar 00:50:14
eliminar botoncito de abajo 00:50:15
y los tres paneles que quedan 00:50:19
son esos para el resto 00:50:21
venga pues ya está 00:50:22
esta aplicación es la que tenéis que completar 00:50:24
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:
21 de marzo de 2025 - 10:55
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
50′ 32″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
212.00 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid