Saltar navegación

20250422 EjerGestionPedidos_1 - Contenido educativo

Ajuste de pantalla

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

Subido el 22 de abril de 2025 por Raquel G.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues venga. Este ejercicio 2, que podría ser también un ejercicio de examen. ¿Quién nos dice a vosotros que el examen próximo no son 3 horas y media? Por ejemplo, porque entonces lo que buscamos en este examen es evaluar otras destrezas. ¿Quién sabe? 00:00:00
bueno pues en un ejercicio como este 00:00:22
aquí ya rápidamente vemos 00:00:25
como primer vistazo que hay clientes 00:00:27
que hay pedidos, que hay rollos, bueno lo de siempre 00:00:29
entonces ahora 00:00:31
antes de hacer cualquier cosa 00:00:33
tenemos que pensar en que 00:00:34
modelo de entidades reproduce la situación 00:00:37
aquí 00:00:39
lógicamente vamos a hacer 00:00:41
un modelo un poquito pintado por encima 00:00:43
como se nos ocurra pero siempre había 00:00:45
siempre habría la mejor manera de hacerlo 00:00:47
y para eso 00:00:49
tendríamos que entender primero 00:00:51
de principio a fin 00:00:53
cuáles son las funcionalidades que quiere el cliente 00:00:54
para ir apuntando 00:00:57
qué propiedades son importantes 00:00:58
de qué propiedades vamos a tirar 00:01:01
para en función de eso, qué entidad meter dentro de la otra 00:01:02
etcétera 00:01:05
bueno, en este caso, ¿qué tenemos? 00:01:06
tenemos gestión de pedidos 00:01:09
ya automáticamente vemos que una entidad de pedidos va a tener que haber 00:01:10
casi seguro 00:01:13
porque de hecho los pedidos tienen varias cosas dentro 00:01:13
código, nombre de cliente 00:01:16
y lista de productos 00:01:19
cada producto a su vez tiene nombre y precio 00:01:20
con lo cual una entidad producto tiene que haber 00:01:24
¿del cliente qué importa? 00:01:26
del cliente parece que solo importa el nombre 00:01:30
porque aquí solo hablan 00:01:32
de que los pedidos tendrán un nombre de cliente 00:01:35
y el resto de funcionalidades son 00:01:38
dado un cliente, un nombre de cliente 00:01:41
los pedidos que ha hecho 00:01:44
no hay ninguna funcionalidad que trabaje con nada del cliente 00:01:45
que no sea su nombre 00:01:50
por supuesto 00:01:51
es un diseño horrible 00:01:53
y el cliente que te pide esto 00:01:56
tú le dirías, mire 00:01:57
claro 00:01:59
tú efectivamente como eres 00:02:01
un buen trabajador le dirías 00:02:03
al cliente tuyo 00:02:06
oiga usted, vamos a replantear 00:02:07
esto, mejor si trabajamos 00:02:10
con DNIs de clientes 00:02:12
o con clientes con más datos 00:02:13
con una agenda de clientes que tenga 00:02:16
su nombre, su DNI por si necesita 00:02:18
usted en un futuro cambiar 00:02:20
a lo mejor alguna de las características 00:02:22
del cliente, ampliar su aplicación 00:02:24
efectivamente 00:02:25
sería el momento de que dejemos de plantearse 00:02:27
las cosas 00:02:30
claro, pero bueno 00:02:30
vamos a hacerla así porque esto es un examen 00:02:33
y tampoco vamos a complicarla 00:02:36
pues ya está 00:02:38
dos clases, pedido y 00:02:39
producto, nos hemos ahorrado la clase cliente 00:02:42
que es una mierda ahorrarse la clase cliente 00:02:44
efectivamente, pero nos la vamos a ahorrar 00:02:46
el cliente es un hombre 00:02:47
bueno 00:02:48
pues entonces 00:02:50
¿cómo vais a hacer 00:02:53
esta aplicación entonces? 00:02:54
¿cómo la vais a completar? 00:02:56
claro, de aquí al jueves 00:02:57
pues venga, ejercicio, pedidos 00:02:59
como ya está dentro de un paquete 00:03:02
porque lo he metido en un único proyecto 00:03:10
para su obra virtual, no puedo hacer paquetes 00:03:12
diferentes para modelo, vista 00:03:14
que pena, lo voy a poner todo junto 00:03:16
pero bueno 00:03:18
pues la clase producto, parece la clase más interna 00:03:18
Pues venga, la clase producto, ¿por qué se caracteriza el producto? Pues el producto se caracteriza por nombre y precio. 00:03:22
Aquí también sería el momento de sentarse con el cliente y decirle, a ver, oiga usted, ¿realmente el producto lo quiere caracterizar por su nombre? 00:03:41
y si tiene dos productos que se llaman igual 00:03:51
sería el momento de sentarse con él 00:03:53
pero vamos a dejarle que nos ha pedido esto 00:03:54
pues le hacemos esto 00:03:57
venga, ya está 00:03:59
get y set 00:04:10
hala 00:04:14
silencio 00:04:18
venga 00:04:21
producto 00:04:23
nombre, precio, get y set 00:04:26
si luego me van haciendo falta 00:04:29
constructores, toString, 00:04:31
equals, ya lo voy volviendo después. 00:04:33
Y pedido. 00:04:36
¿Qué va a tener el pedido? 00:04:50
Pues el pedido tiene 00:04:53
el código 00:04:54
el nombre de cliente 00:05:08
vale, aquí realmente 00:05:12
el siguiente paso 00:05:20
de esta aplicación efectivamente 00:05:22
sería quitar este string 00:05:23
y poner esto 00:05:26
sería el siguiente paso 00:05:27
pero bueno, vamos a hacer la versión sencilla 00:05:29
sobre todo queremos ahora trabajar con serializar objetos 00:05:31
recordar un poco de colecciones 00:05:35
y ya está 00:05:37
Ah, y la lista de productos 00:05:38
Lista de productos 00:05:41
Vamos a poner una lista 00:05:43
En lugar de una line, ¿te parece? 00:05:47
Ya, eso lo decís todos 00:05:51
Venga 00:05:52
Una lista de productos 00:05:53
Eso no es un reto 00:05:57
Para tu inteligencia, ¿verdad? 00:06:02
Usar listas 00:06:03
New 00:06:04
linked list 00:06:08
ya está 00:06:12
fíjate 00:06:16
vale, es el momento 00:06:22
bueno, hacemos los get y set 00:06:24
pero realmente vas a poner a hacer esto en un blog de notas 00:06:26
alguna vez 00:06:33
Dios no lo quiera 00:06:33
venga, entonces aquí ya sí que es el momento 00:06:35
de pararse a pensar, es decir 00:06:40
cuidado que voy a trabajar con una lista de productos 00:06:42
es muy probable 00:06:45
que quiera yo comprobar 00:06:46
si está el producto en la lista 00:06:48
etcétera, entonces me interesa 00:06:51
ahora ya sí que sí 00:06:53
definir un criterio de igualdad 00:06:54
entre productos 00:06:57
le tendría que preguntar al señor 00:06:58
hay poco que elegir 00:07:00
en este caso está claro que el criterio de igualdad 00:07:02
en productos va a ser el nombre 00:07:04
bueno, pues entonces 00:07:06
aquí ha llegado el momento de poner un 00:07:08
equals 00:07:10
por el nombre 00:07:11
me deja el jascón 00:07:14
bueno, no pasa nada, lo podríamos dejar 00:07:16
porque es el momento dado, usamos un conjunto 00:07:18
vamos a dejarlo 00:07:20
y se acabó 00:07:23
de hecho 00:07:24
aquí podríamos nosotros 00:07:26
ya como programadores 00:07:28
decir, a ver, no sería, teniendo en cuenta 00:07:29
que un conjunto es más eficiente 00:07:32
computacionalmente 00:07:34
¿realmente es necesario que yo use una lista? 00:07:35
¿voy a necesitar 00:07:39
duplicados? 00:07:40
es decir, un pedido 00:07:42
puede tener 00:07:44
el mismo producto 00:07:45
con el mismo nombre 00:07:47
en diferentes precios 00:07:49
si es así 00:07:51
es que esta aplicación está mal planteada 00:07:53
sería casi mejor cambiar la clase producto 00:07:55
cambiar la clase todo 00:07:57
entonces si hemos puesto 00:07:58
que el producto se caracteriza solo por nombre y precio 00:08:01
será seguramente 00:08:03
porque mi aplicación no admite 00:08:05
que 00:08:07
a ver, podría tener sentido 00:08:07
que si hubiera una tercera 00:08:11
propiedad fecha 00:08:13
que un cliente tuviera 00:08:14
diferentes productos 00:08:17
pero en diferente fecha 00:08:18
a lo mejor, entonces en su lista puede tener el mismo nombre 00:08:21
de producto en diferente fecha 00:08:23
pero el equal no querría seguir 00:08:25
teniendo por nombre 00:08:27
hay las fechas 00:08:28
bueno, entonces 00:08:32
cada situación realmente 00:08:34
cada situación es muy distinta 00:08:36
entonces es importante 00:08:40
no conocer solamente 00:08:41
cómo se programa y se tira código 00:08:43
sino saber entender exactamente 00:08:45
qué necesito 00:08:47
entonces, silencio 00:08:48
repito 00:08:52
imagina esta situación 00:08:53
yo le voy a 00:08:54
le preguntáis al que os ha pedido la aplicación 00:08:56
¿le vas a permitir 00:08:59
al señor, al cliente 00:09:01
que te compre la misma cosa 00:09:03
en diferentes fechas, si él te 00:09:05
dice sí 00:09:07
pues entonces tú meterías 00:09:09
aquí una propiedad fecha 00:09:11
ahora ya te entra, un segundo, te entra 00:09:12
una duda, que es 00:09:15
mi equals seguiría siendo 00:09:17
por nombre o pondría por nombre y fecha 00:09:19
depende 00:09:21
vamos a ver las funcionalidades de la aplicación 00:09:23
¿hay alguna funcionalidad que sea 00:09:25
mira a ver 00:09:26
qué clientes han pedido el producto 00:09:29
boli, porque si la hay 00:09:31
me interesa que el equals sea solo 00:09:33
por nombre, con lo cual 00:09:35
si el equals es solo por 00:09:37
nombre, pero voy a permitir 00:09:39
que en una misma lista 00:09:41
de pedidos haya el mismo producto 00:09:43
con el mismo nombre en diferentes fechas 00:09:45
ahora ya sí que tengo que usar 00:09:47
obligatoriamente una lista, ya 00:09:49
sí que no podría usar un set 00:09:51
entonces todas estas consideraciones 00:09:52
son las que, con las que tienes 00:09:55
que estar familiarizado y tener claras 00:09:57
vale, ahora te entra a ti un dilema que eso 00:09:58
no me gusta nada 00:10:01
porque vas a poner un aprieto 00:10:02
de hecho estoy por no grabar el dilema 00:10:04
no porque vas a poner apuros 00:10:06
pues venga, no grabamos el dilema 00:10:08
pues seguimos 00:10:10
entonces en nuestro caso 00:10:11
hemos dicho, mira 00:10:16
el cliente me ha dicho que no va a permitir 00:10:17
al usuario hacer 00:10:20
en la misma lista de pedidos 00:10:22
el mismo pedido 00:10:25
varias veces 00:10:26
con lo cual el campo fecha 00:10:27
Aquí no tiene sentido ni nada. 00:10:29
Luego, ¿para qué voy a usar un list? 00:10:31
Si no voy a necesitar duplicados, 00:10:33
no voy a necesitar duplicados, 00:10:35
es decir, dos productos iguales según el criterio de igualdad, 00:10:37
no me van a hacer falta, que coexistan. 00:10:40
¿Para qué usar un list? 00:10:43
Que es mucho más computacionalmente, más complejo, 00:10:44
porque tiene que llevar internamente el registro de las posiciones. 00:10:47
Pues hombre, un set y ya está. 00:10:50
Vale, pues un set. 00:10:53
¿Vale? 00:10:55
Pero insisto, un set, ¿por qué? 00:10:56
Porque la igualdad de producto es solo por nombre y no vamos a admitir productos con el mismo nombre. 00:10:58
¿Qué versión de set instanciamos? 00:11:06
Pues el hash set siempre sería la más cómoda. 00:11:08
El triset también es muy rápida y el triset lo que nos permite es que alguna vez vamos a sacar productos ordenados por el criterio de igualdad, 00:11:12
que en este caso es el nombre. 00:11:23
¿Va a haber algún listado alfabético de productos? 00:11:24
Pues si lo va a ver, me viene genial el triset, porque es que el triset ya por naturaleza te inserta las cosas en el orden del criterio de igualdad. 00:11:28
Entonces, venga, como no suele gustar el triset, vamos a poner el triset, ¿vale? 00:11:37
Y así cuando yo liste los productos del cliente, me los va a listar en orden alfabético, sin tener yo que hacer nada, porque ya el triset trabaja así. 00:11:43
vale, pero si uso 00:11:52
un set y un triset 00:11:54
efectivamente 00:11:55
si uso un triset 00:11:57
ese jasco de equals 00:12:00
que tenía, no lo va a necesitar 00:12:02
tampoco molesta 00:12:04
pero el comparable 00:12:05
si va a hacer falta 00:12:08
ahora me viene la siguiente duda 00:12:09
a lo mejor producto 00:12:12
yo no tengo 00:12:14
la posibilidad de tocarla 00:12:15
porque producto no lo he hecho yo, es una clase 00:12:17
a la que yo no tengo permisos para editar 00:12:20
he importado el jar y puedo 00:12:22
instanciar objetos producto y todo eso 00:12:24
puedo instanciarlos, pero no puedo editar el código fuente 00:12:26
si yo no puedo editar el código fuente 00:12:29
no puedo entonces 00:12:32
usar un triset 00:12:34
si puedo 00:12:35
porque había un plan C 00:12:40
¿alguien se acuerda? 00:12:42
el terminator, comparator 00:12:46
hacer un criterio de igualdad 00:12:48
específico para la aplicación 00:12:51
aparte y dárselo al triset 00:12:53
decirle, oye triset, como el criterio 00:12:55
de igualdad no lo vas a sacar de producto 00:12:57
porque no te lo puedo poner ahí 00:12:59
te voy a hacer yo uno aparte 00:13:00
y te lo paso aquí por constructor 00:13:03
¿vale? 00:13:04
vamos a hacerlo así 00:13:06
vamos a pensar que en producto yo no puedo implementar 00:13:07
comparable, si pudiera está 00:13:11
claro, implement comparable 00:13:13
y ahora hacemos aquí 00:13:15
vamos a ponerlo aunque luego lo comentemos 00:13:16
implements 00:13:18
comparable 00:13:20
de producto 00:13:22
todo esto si que recupera 00:13:24
colecciones 00:13:27
también llamada RA6 00:13:27
si implementamos comparable 00:13:30
tenemos que implementar 00:13:34
este método, ahora este método 00:13:36
es que tengo que apañarmelas yo para que me devuelva 00:13:38
positivo si el objeto que llama 00:13:41
el método va antes, cero 00:13:42
bueno, pues nos tenemos que preguntar 00:13:44
¿cuál va a ser mi propiedad 00:13:47
para comparar uno con otro? 00:13:49
el nombre 00:13:51
el nombre es un string 00:13:52
el string, la clase string 00:13:54
ya tiene un método compareTo 00:13:57
que me permite comparar un string con otro 00:13:58
pues directamente lo usamos 00:14:00
return 00:14:03
dis.nombre 00:14:04
que es la propiedad nombre del que llama el método 00:14:07
compareTo 00:14:09
o.nombre 00:14:10
o es este tan feo de aquí 00:14:12
ala, ya tengo el 00:14:14
si el que llama 00:14:18
al método está antes 00:14:20
alfabéticamente me devolverá positivo 00:14:22
si el que llama al método es 00:14:24
el mismo nombre que el que le paso 00:14:26
me devolverá cero, y si el que llama al método 00:14:28
es alfabéticamente 00:14:30
posterior al parámetro 00:14:32
me devolverá negativo, justo lo que yo quería 00:14:34
porque el compare to the string funciona así 00:14:36
vale, pero resulta que yo no puedo 00:14:38
trabajar con producto 00:14:40
esto que yo he hecho, que ahora dejo aquí comentado 00:14:42
no puedo hacerlo 00:14:45
que pena, más grande 00:14:47
esto no lo puedo hacer 00:14:51
tengo que renunciar 00:14:58
al triset, no, no tengo que renunciar 00:15:02
al triset, vamos a hacer un criterio de comparación 00:15:04
aparte, los criterios 00:15:06
de comparación 00:15:08
son implementaciones de la interfaz 00:15:08
comparator 00:15:12
pues vamos a hacer un criterio de comparación 00:15:13
aquí 00:15:16
compara nombres 00:15:16
por ejemplo 00:15:23
este es un criterio de comparación 00:15:23
¿no puedes crear la 00:15:27
conglomeración interna? 00:15:29
sí, podría, pero no lo voy a hacer 00:15:30
para no liar, pero sí, si solo lo voy a usar ahí 00:15:33
claro, efectivamente 00:15:35
comparator 00:15:37
¿de qué? de producto 00:15:41
porque este va a ser para comparar 00:15:43
productos 00:15:45
luego esto es 00:15:46
no es una entidad, no es un objeto 00:15:52
no es una entidad, no representa ninguna realidad 00:15:54
representa un criterio 00:15:57
para comparar, bueno pues 00:15:58
si es un criterio para comparar, tiene que 00:16:00
implementar 00:16:02
el compare 00:16:03
y este compare me tiene que comparar 00:16:05
el O1 con el O2 00:16:08
el O1 con el O2 se comparan de nuevo 00:16:10
en función del nombre 00:16:12
pues el compare tú del nombre 00:16:13
pues ya está, O1 00:16:16
punto nombre 00:16:18
get nombre 00:16:20
porque no vale 00:16:23
compare tú 00:16:24
o dos 00:16:26
punto getNombre 00:16:27
ya está 00:16:29
a ver 00:16:33
este es un método 00:16:40
que simplemente está diseñado 00:16:42
para que te permita 00:16:44
dos objetos, el que llama y el otro 00:16:46
mediante la obtención 00:16:48
de un número entero que puede ser positivo 00:16:50
cero, negativo, decirte 00:16:52
si uno está delante, si otro está detrás 00:16:54
o si son el mismo 00:16:56
0 si son el mismo 00:16:57
positivo si este está detrás 00:16:59
y negativo si este está delante 00:17:01
y eso 00:17:03
esa forma de comparar la usan muchas clases 00:17:04
entre ella y el triset, por eso lo necesitamos 00:17:07
entonces 00:17:09
ahora ya hemos hecho 00:17:12
un criterio de comparación 00:17:15
ahora ya 00:17:17
al triset le decimos 00:17:19
oye triset 00:17:21
úsame 00:17:22
un objeto 00:17:24
criterio de comparación 00:17:26
que sea este. 00:17:28
Compara nombres. 00:17:30
Ya está. 00:17:36
¡Hala! 00:17:39
Pues ahora ya podremos 00:17:41
hacer triset 00:17:43
de productos, porque el triset 00:17:45
ya va a saber a qué criterio recurrir 00:17:47
a la hora de meterlos en el árbol. 00:17:49
Ya va a saber a qué criterio 00:17:52
recurrir. Aquí lo único es que 00:17:53
el set lo voy a 00:17:55
tener que cambiar. 00:17:57
vale, pues ya tengo 00:17:59
todas las clases que me hacen falta 00:18:11
¿hay por ahí más entidades en mi aplicación 00:18:13
que tengan propiedades dentro? pues no 00:18:17
porque el cliente es solo el nombre 00:18:19
no hay nada más 00:18:21
entonces si esto 00:18:22
representa todo lo que el usuario 00:18:25
necesita, pues ya está 00:18:27
ahora ya 00:18:30
sí que empezaría a 00:18:31
primero debería yo entender bien 00:18:33
lógicamente lo que va a hacer, nos hemos ahorrado 00:18:36
esa lectura para entender lo que hace cada cosa 00:18:38
pero bueno, suponemos que 00:18:40
eso ve la marcha, ahora ya sí 00:18:41
tendremos que hacer en frame 00:18:44
con las dos pestañas, insertar 00:18:46
y consultar 00:18:48
insertar pues para cada 00:18:49
cliente, insertar todo esto 00:18:52
de aquí, entonces ahora 00:18:54
cuando ya 00:18:56
empezamos la aplicación que funciona 00:18:58
nos viene otro dato que vamos 00:19:00
a fijar ya antes de que lo hagáis, 00:19:02
¿qué es? Pero, ¿mis datos dónde están? 00:19:04
¿Mis datos quiénes son? 00:19:06
¿Mis datos son 00:19:08
clientes, pedidos? ¿Cuáles son mis datos? 00:19:09
Vamos a ver. 00:19:12
Vale, pues a ver. 00:19:16
Esto me va a hacer 00:19:18
a un cliente insertar 00:19:20
productos. 00:19:23
Nombre y precio, que pongamos aquí. 00:19:26
Nombre y precio. Vale. 00:19:28
Entonces, 00:19:32
ese cliente 00:19:33
con ese nombre 00:19:35
tendrá 00:19:36
los pedidos 00:19:39
vale 00:19:41
pues ya está 00:19:42
los datos de mi aplicación van a ser 00:19:49
los conjuntos de los pedidos 00:19:51
que tenga 00:19:53
cada insertar me genera 00:19:54
un pedido de productos 00:19:58
para ese cliente 00:19:59
aquí abajo en esta área de texto 00:20:00
poniendo nombre guión precio 00:20:06
ahí al darle insertar 00:20:08
habrá que sacarlo de ese área de texto 00:20:10
luego los datos de mi aplicación 00:20:12
van a ser la lista de pedidos 00:20:14
luego vamos a hacer eso ya por último 00:20:16
mi aplicación 00:20:18
¿cuáles van a ser sus datos? 00:20:20
pues vamos a meterlos 00:20:22
en una clase datos por ejemplo 00:20:23
y aquí van a estar los datos de mi aplicación 00:20:26
venga 00:20:30
los pedidos ya vamos a poner que sean una lista 00:20:35
bueno, pues aquí están mis datos 00:20:37
en lugar de una base de datos 00:20:55
están ahí, inicialmente siempre vacíos 00:20:57
vale, luego 00:20:59
antes de empezar a hacer nada 00:21:01
primero hay que diseñar bien las clases 00:21:02
con las que va a trabajar mi aplicación 00:21:05
y luego tengo que preguntarme por los datos 00:21:06
¿mis datos dónde están? 00:21:09
pues mis datos, ¿qué van a ser? 00:21:11
la lista de pedidos 00:21:14
cada pedido tendrá su nombre 00:21:15
de cliente dentro y sus productos 00:21:17
esos van a ser mis datos 00:21:18
los datos podrían haber sido 00:21:19
si hubiéramos tenido la clase cliente 00:21:23
pues la lista de clientes 00:21:25
con los pedidos dentro 00:21:27
depende, en mi caso, tal y como están las clases 00:21:28
diseñadas, los datos 00:21:31
van a ser la lista de pedidos, porque los pedidos 00:21:33
no tienen todo dentro, el pedido tiene 00:21:35
dentro el nombre del cliente y los productos 00:21:37
entonces mis datos tienen que ser 00:21:38
una colección de objetos que tengan 00:21:40
todo lo demás dentro, que tengan todo lo demás 00:21:43
pues el pedido es el que tiene 00:21:45
todo lo demás dentro, porque tiene el nombre 00:21:47
del cliente y los productos, pues mis datos 00:21:49
van a ser la lista de pedidos. 00:21:51
Vale, ahora ya que tengo claro cuáles van a ser mis datos 00:21:54
y dónde van a estar, ahora ya sí que entraríamos 00:21:58
a hacer la interfaz y irnos a los eventos. 00:22:02
Que en este caso, tal y como está, 00:22:08
es el evento del botón insertar y el evento del botón consultar. 00:22:10
Ya está, los eventos. 00:22:16
Venga, pues hacéis la interfaz y completáis los eventos 00:22:20
y el evento de la clase anterior. 00:22:23
Y paramos aquí, pero aquí nos falta lógicamente 00:22:27
que los datos se tienen que guardar en un fichero. 00:22:37
Hay que serializarlo. 00:22:41
O sea, la aplicación cuando arranca 00:22:42
cargará estos pedidos de un fichero. 00:22:44
Luego esta clase de datos tendrá que tener 00:22:49
recupera pedidos. 00:22:51
tendrá que tener este método 00:23:05
que 00:23:11
del objeto fichero 00:23:13
que le pasemos, me recupera 00:23:15
los pedidos que ya hay y los guarde 00:23:17
aquí, y también tendrá 00:23:19
que tener un método 00:23:21
para que cuando la aplicación termine, guarde 00:23:22
los pedidos antes 00:23:33
o la aplicación cuando arranca entonces 00:23:34
solicitará 00:23:53
el nombre del fichero de pedidos 00:23:55
con un jOptionPane 00:23:56
por ejemplo, y tratará de 00:23:58
recuperar los que hay 00:24:00
y los guardará aquí y ya está. 00:24:01
La aplicación luego trabaja 00:24:05
y en el momento de salir, 00:24:06
antes de salir, los volverá a guardar. 00:24:09
Pues nada, ese es el trabajo que falta por hacer. 00:24:12
La interfaz, dos eventos y ya está. 00:24:15
Si es lo mismo que la aplicación de facturas que hicimos 00:24:16
para ver esto de securización, 00:24:18
ya está. 00:24:21
Venga, pues vamos a dejarlo aquí. 00:24:22
Intentad hacerlo, 00:24:26
tratad de hacerlo porque el próximo día 00:24:27
lo vamos a tunear 00:24:29
para que tenga un poquito más de complejidad el acceso a ficheros y todo eso. 00:24:29
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:
16
Fecha:
22 de abril de 2025 - 17:56
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 36″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
104.81 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid