Saltar navegación

Clase 26-04-24 - 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 6 de mayo de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

El 5 es el primero en el cual se incorpora la necesidad de investigar un componente nuevo. 00:00:01
Claro, pero es que componentes posibles de swing hay tropecientos mil. 00:00:06
Entonces continuamente uno puede necesitar investigar un componente nuevo para incorporarlo. 00:00:10
Y ya está. 00:00:15
Pues este es un componente nuevo a investigar que uno busca. 00:00:16
¿Y este cuál es? ¿Este swing cómo lo llama? 00:00:18
Ah, vale, este es el combo box, que es el desplegable de toda la vida. 00:00:20
Pues una vez que uno identifica, ah, es así, pues ya estudia un poquito cómo funciona. 00:00:24
que siempre será, lo integro en mi aplicación 00:00:28
lo añado 00:00:31
a mi panel 00:00:33
veo los métodos que tiene 00:00:33
para hacer las cosas 00:00:36
que a mí me interesan 00:00:39
en este caso el desplegable tendrá métodos 00:00:40
de añadir al desplegable 00:00:43
eliminar del desplegable 00:00:45
coger lo que esté seleccionado 00:00:46
pues veo los métodos que tiene 00:00:48
y luego en el caso de que quiera capturar un evento 00:00:50
sobre él, pues sería 00:00:53
voy a probar el ActionListener, cómo funciona 00:00:55
o si no voy a ver 00:00:57
que otro evento se adapta, si el de hacer clic 00:00:59
con el mouse, listener 00:01:01
esa es la dinámica, bueno pues en este caso 00:01:03
si uno hace esto así de corrido 00:01:06
así a lo bestia 00:01:11
pues lo que habréis hecho habrá sido lo de siempre 00:01:12
esto 00:01:20
heredando 00:01:22
del JFrame 00:01:23
y un constructor 00:01:26
y ahora en este 00:01:27
pues todavía vamos a poner todos los componentes 00:01:34
uno detrás de otro con un gestor de ubicación 00:01:36
normal y corriente 00:01:38
vale, y ahora añadimos los componentes 00:01:40
entonces 00:02:08
importamos el frame 00:02:09
vale, componentes 00:02:12
vamos a decidir cuáles 00:02:15
dos áreas de texto, dos etiquetas 00:02:16
y un botón 00:02:18
y un componente de estos 00:02:20
que tenemos que averiguar cuál es 00:02:22
una vez que uno lo averigua lo pone 00:02:23
¿dónde ponemos los componentes? 00:02:25
bueno, pues tenemos dos posibilidades 00:02:28
o aquí fuera como propiedades de la clase 00:02:29
o dentro como variables locales 00:02:32
del constructor 00:02:34
si vamos a tener 00:02:35
que acceder a esos 00:02:38
componentes desde clases 00:02:40
internas, desde aquí 00:02:42
que aquí pondremos las clases 00:02:44
internas que son los capturadores 00:02:46
si vamos a tener que acceder a esos componentes 00:02:48
el sitio para ponerlos 00:02:50
es ahí, para tener acceso 00:02:52
a las clases internas 00:02:54
si no vamos a tener que acceder a ellos, pues los puedo declarar 00:02:55
dentro, entonces en este caso 00:02:58
uno podría pensar, vamos a ver 00:03:00
esto 00:03:02
¿cómo va a funcionar? 00:03:04
bueno pues, ¿cuáles 00:03:07
de estos elementos van a tener 00:03:08
que ser capturados 00:03:10
o evento? el botón 00:03:12
porque cuando demos al botón algo va a tener 00:03:14
que pasar, cuando demos al botón 00:03:16
va a tener que pasar, que cojamos 00:03:18
lo que hay en este área de texto, cojamos lo que 00:03:20
hay en este área de texto y lo guardemos 00:03:22
en algún sitio 00:03:24
para tenerlo ahí 00:03:25
para cuando haya que tirar de él 00:03:27
y luego además que se actualice aquí 00:03:28
luego 00:03:30
este área de texto 00:03:32
este área de texto 00:03:35
y este combo box tienen que ser accesibles 00:03:36
desde las clases internas 00:03:39
que están fuera del 00:03:41
constructor, que están fuera 00:03:42
luego esas tres áreas de texto 00:03:44
como mínimo tienen que estar fuera 00:03:46
esas tres áreas de texto como mínimo 00:03:48
tienen que estar fuera 00:03:50
pues entonces las ponemos fuera 00:03:51
vale, ahí va a estar el área de texto de título 00:03:53
que la declararíamos ya 00:03:57
con el tamaño que nos diera la gana 00:04:04
el tamaño visible 00:04:05
no el que cabe, el que cabe, cabe mucho más 00:04:07
el visible, el otro 00:04:10
y hemos dicho que como 00:04:22
este elemento también tiene que estar 00:04:28
visible desde 00:04:30
Daniel, tiene que estar visible 00:04:32
desde las clases 00:04:34
capturadoras que están 00:04:36
fuera del constructor 00:04:38
también tiene que estar visible, tenemos que ponerlo 00:04:40
también aquí, entonces 00:04:42
después de hacer la fase de ver, oye y este desplegable 00:04:44
¿cuál es? swing, ¿cómo lo llama? 00:04:46
ah, es el jcombo box, pues nada 00:04:48
me pongo ahí 00:04:50
un jcombo box 00:04:52
y ya de paso, pues lo instancio 00:04:53
¿vale? 00:05:01
entonces 00:05:12
vale 00:05:13
ahí, vale 00:05:27
entonces aquí ya 00:05:29
ya se, me salta una pequeña 00:05:30
una pequeña alarma que es que 00:05:33
me dice un aviso amarillo, no un error 00:05:35
me dice, combo box 00:05:37
en una clase genérica, deberías parametrizarla 00:05:39
bueno, entonces yo esa 00:05:41
alarma por ahora me la dejo ahí 00:05:43
registrada como diciendo, en algún momento 00:05:45
entenderé a qué se refiere 00:05:47
por ahora voy a seguir tirando 00:05:48
porque bueno, ese elemento se llama combo box 00:05:51
yo lo he instanciado, me ha dejado y lo voy a añadir 00:05:53
vale 00:05:56
y ese aviso pues me lo dejo 00:05:56
ahí registrado como, uy voy a tener que volver 00:06:00
a sobre esto seguramente en algún momento 00:06:02
cuando tenga mi aplicación más avanzada 00:06:04
y la esté probando, seguramente haya que volver. 00:06:06
Vale, pues por ahora no lo dejamos ahí, ese proceso. 00:06:08
Vale, entonces, ¿el resto de componentes es necesario que vayan fuera? 00:06:12
Bueno, las etiquetas no, las etiquetas se ponen ahí 00:06:18
y ninguna clase interna las toca para hacer nada. 00:06:21
La aplicación va funcionando y las etiquetas están ahí inamovibles, 00:06:24
las de tu director, están ahí que no se mueven. 00:06:27
Nadie las tiene que tocar, pues las puedo declarar dentro del constructo 00:06:30
y las dejo como locales, por ejemplo. 00:06:33
el botón 00:06:34
hay que añadir el evento 00:06:36
pero el botón se toca, se cambia 00:06:38
se le cambia el nombre, se hace algo con él 00:06:41
pues no, el botón no se le toca 00:06:43
tampoco, está ahí inamovible 00:06:45
entonces puede declarar localmente a la aplicación 00:06:46
en principio, venga pues lo declaro 00:06:49
dentro, todo lo que uno declare local 00:06:51
si puede, mejor 00:06:53
porque todo lo local 00:06:55
al estar más escondido 00:06:57
es más fácil que no de problemas al resto de la aplicación 00:06:58
que no genere 00:07:02
ambigüedades, entonces todo lo que sea local 00:07:02
pues local, bueno pues 00:07:05
lo que es local es lo que me falta 00:07:07
la etiqueta de título 00:07:09
y ya le vamos a poner en el constructor lo que queremos 00:07:10
que figure en ella 00:07:20
la etiqueta en la que pone 00:07:22
director 00:07:33
me he adelantado al siguiente paso 00:07:34
esta es la etiqueta sin más 00:07:44
que no se va a tocar, nadie más la va a 00:07:49
tocar una vez puesta en la 00:07:52
una vez puesta en la interfaz 00:07:53
entonces la declaramos local y mejor 00:07:55
y el botón, el botón también 00:07:57
una vez pegado en la interfaz 00:08:02
el programa ya no lo toca más 00:08:03
no lo tiene que tocar más para nada 00:08:06
lo toca el usuario cuando hace click 00:08:08
pero el programa ya no lo vuelve a tocar 00:08:09
pues entonces local ahí 00:08:11
vale, pues ahora ya lo único que falta es añadirlos 00:08:13
lo ideal sería pues trabajar 00:08:41
con un gestor de ubicación 00:08:43
absoluta, con un gestor grid layer 00:08:45
lo que fuera para colocarlo yo como yo lo quisiera 00:08:46
pero nosotros toda esa parte de jugar con los gestores 00:08:48
de ubicación directamente por código 00:08:51
la dejamos, la tenéis muy bien documentada 00:08:52
en la API de Java 00:08:56
en los libros, donde sea 00:08:58
pues vamos a añadirlos al menos 00:08:59
por orden para que se entienda, primero vamos a añadir 00:09:02
al panel 00:09:04
vamos a añadir 00:09:05
la etiqueta de título 00:09:10
añadimos 00:09:12
la etiqueta de título 00:09:15
luego vamos a añadir el área de texto 00:09:17
para el título 00:09:20
vamos a añadir el área de texto para el título 00:09:21
que es este 00:09:32
Luego vamos a añadir la etiqueta 00:09:33
Para el director 00:09:37
Luego vamos a añadir 00:09:41
El área de texto para el director 00:09:44
Que era este 00:09:50
Luego vamos a ponerle el botón 00:09:51
Para que al menos tenga un poquito de orden 00:09:53
Le vamos a añadir el botón 00:09:55
Y luego le vamos a añadir ya 00:09:57
El desplegable 00:10:01
Vale, mi interfaz está 00:10:02
Le vamos a dar 00:10:13
tamaño aquí mismo 00:10:14
dis.setSize 00:10:16
o setSize, como lo queréis llamar, le vamos a dar 00:10:20
pues yo que sé, 200 00:10:22
200, a ver como sale 00:10:24
y le vamos a hacer 00:10:25
visible 00:10:28
ya dentro del constructor directamente 00:10:28
bueno, pues mi constructor 00:10:32
ya lo hace todo, mete los componentes 00:10:36
en el panel 00:10:38
hace visible, esto es como poner 00:10:40
dis, obviamente, ¿no? 00:10:42
a este frame, a este, fíjale este tamaño 00:10:44
pero como el dis es opcional 00:10:46
Vale, y ahora nos falta un main 00:10:47
Vale, y ahora nos falta un main 00:10:52
Para poder lanzar la aplicación 00:11:01
Vamos a meter el main aquí mismo 00:11:02
Y así no nos tenemos que hacer una clase aparte 00:11:04
Para hacer las pruebas 00:11:07
Esto solamente para facilitar la fase de pruebas 00:11:09
Lo normal en una aplicación 00:11:14
Es que el arrancable 00:11:17
Estaría en otro sitio 00:11:19
Vale, pues aquí creamos la ventana 00:11:19
Y ya está 00:11:23
Es que ya, como aquí 00:11:23
Ni voy a hacer el Vset visible y nada 00:11:30
Porque lo he hecho aquí 00:11:32
Es que ni siquiera tengo por qué guardar la referencia 00:11:33
Ya, si no me da la gana 00:11:36
¿Para qué voy a guardar la referencia? 00:11:37
No me hace ninguna falta 00:11:39
Porque este Main no hace más que esto 00:11:40
No hace más 00:11:42
Vale 00:11:44
Entonces, la vista estaría 00:11:44
Vamos a probarla 00:11:47
Luego falta el comportamiento 00:11:48
La vista está, vamos a probar 00:11:50
si es como la que queremos 00:11:53
va a estar fea porque va a estar todo seguido 00:11:55
ah bueno, es que no he fijado el gesto de ubicación 00:11:58
pues obviamente estaba muy fea 00:12:01
entonces al panel 00:12:03
al panel hay que fijarle 00:12:05
el layout 00:12:09
este de aquí, ala, ya está 00:12:10
fija el panel, volvemos a hacer la prueba 00:12:13
vale, siempre 00:12:14
hay que hacer 00:12:17
las pruebas primero de la 00:12:18
vista, antes de meterse 00:12:21
con el comportamiento 00:12:23
Bueno, pues hombre 00:12:23
Pues joder, he acertado con el tamaño 00:12:26
Porque es que me queda 00:12:28
De casualidad, porque queda bien 00:12:28
Título, abajo el título, director 00:12:31
Abajo el director, añado película 00:12:33
Y aquí el desplegable que además no tiene nada 00:12:35
Está vacío 00:12:37
Vale, pues muy bonita mi interfaz 00:12:38
Es la justo la que quería 00:12:42
Pues ahora ya voy a dar comportamiento 00:12:43
A los eventos que lo tengan 00:12:46
A los componentes que lo tengan 00:12:47
¿Qué dos componentes? 00:12:49
Cada vez que yo le dé al botón 00:12:51
hay que coger el título que hay aquí 00:12:52
y el director que hay aquí 00:12:55
y guardarlo 00:12:57
idealmente en una base de datos 00:12:59
que no tenemos, pero guardarlo 00:13:01
vale, y luego además 00:13:03
este combo box 00:13:07
se va a tener que actualizar de tal manera 00:13:08
que registre que tenga 00:13:11
todos los títulos que están guardados 00:13:13
vale, entonces 00:13:15
este tiene que recoger un evento 00:13:18
y ahora, ¿qué más hace la aplicación? 00:13:20
pues cuando tú despliegas el combo box y haces clic 00:13:22
en un título 00:13:24
te aparecerá aquí el director de la película 00:13:25
luego dos funcionalidades 00:13:28
añadir película a mi 00:13:30
almacén de películas 00:13:32
y ahora cuando en el 00:13:34
combo box selecciono un título 00:13:36
me aparecerán los datos de esa peli 00:13:38
que en este caso es el director solo 00:13:40
pero podría haber aquí 00:13:41
muchos más textfield con título, director, año 00:13:44
intérpretes, bla bla bla 00:13:46
podría yo guardar todo eso 00:13:47
extendido y cuando yo selecciono aquí el título 00:13:49
pues que me aparezcan todos 00:13:52
Entonces he puesto solo director para no perder el tiempo 00:13:54
Haciendo lo mismo una y otra vez 00:13:57
Pero sería lo mismo 00:13:58
Vale 00:13:59
Los testfields he puesto 20 00:14:00
Pero vamos, que lo he hecho todo 00:14:06
De pura casualidad 00:14:09
Y ha encajado en un aspecto más o menos normal 00:14:10
Porque 00:14:13
Ahora lo estiro 00:14:16
Pues me queda así, que no queda mal tampoco 00:14:18
Vale 00:14:20
Entonces este tamaño 00:14:22
Si pudiera pillarlo 00:14:26
Y dejarlo 00:14:27
Este estaría mejor 00:14:29
Pero este tamaño igual es 00:14:30
400 por 00:14:33
Única prueba que hago, no voy a perder el tiempo con esto 00:14:36
Voy a probar 00:14:39
A ver si 00:14:50
400, bueno 00:14:51
Una prueba más solo, 600 00:14:58
A ver si 600 queda mejor 00:15:00
Lo de 75 un poco corto 00:15:03
120 00:15:16
Y ya está 00:15:18
Ya lo dejo 00:15:20
no ha quedado mal, para ser un flow layout 00:15:21
no ha quedado mal 00:15:34
vale 00:15:36
pues entonces ahora vamos con el comportamiento 00:15:36
vamos a hacer una capturadora 00:15:39
para este y otro capturadora 00:15:42
para este 00:15:44
a ver, podríamos meterlo en la misma capturadora y decir 00:15:44
si el objeto que causó el evento 00:15:48
equals este 00:15:50
jbutton, pues entonces 00:15:51
no sé qué, y si no 00:15:53
es que será este otro 00:15:56
si lo hago así, con un 00:15:57
if y un else, lo único que cambia es que entonces 00:15:59
desde ese evento sí que necesito 00:16:01
el acceso al botón 00:16:03
entonces tendría que sacarlo fuera 00:16:06
tendría que sacar la declaración 00:16:07
de esto fuera 00:16:10
pero en este caso 00:16:10
lo que se hace en el if y en el else 00:16:13
son dos cosas muy distintas 00:16:16
son dos códigos muy distintos 00:16:17
entonces siempre por principio 00:16:19
no hagamos métodos largos 00:16:21
¿para qué? es mucho mejor 00:16:23
tener un montón de clases pequeñas 00:16:26
que una única clase muy larga 00:16:28
es mejor tener un montón de métodos pequeños 00:16:29
que un único método muy grande 00:16:33
esos son principios de programación básicos 00:16:34
vamos a atomizar todo lo que podamos 00:16:37
y luego ya tú vas llamando a lo que te haga falta 00:16:39
pero es mucho más fácil 00:16:41
seguir una cadena de llamadas a métodos 00:16:42
porque el propio nombre del método 00:16:44
te informa de lo que está pasando 00:16:46
entonces es más fácil seguir una llamada 00:16:48
añade no sé qué 00:16:50
borra esto, borra no sé cuántos 00:16:52
es más fácil seguir una línea de llamada de métodos 00:16:54
que seguir un código con sentencias 00:16:56
java así de largo que te hace todo eso 00:16:58
entonces 00:17:01
en este caso, ¿qué es lo que quiero decir? 00:17:02
¿para qué hacer dos clases? 00:17:05
¿para qué hacer una única clase capturadora? 00:17:06
para aglutinar los dos 00:17:08
cuando lo que se hace con el botón 00:17:10
es muy diferente a lo que se hace con el combo box 00:17:12
entonces dentro de la capturadora tendrás 00:17:14
if es el botón, pa pa pa, un chorizo 00:17:16
else, pa pa pa, otro chorizo, pues no, para eso te haces 00:17:18
dos clases y lo separas en dos clases 00:17:20
¿vale? 00:17:23
bueno, pues entonces vamos a hacernos primero 00:17:24
la clase que va a atender 00:17:26
al botón este de aquí 00:17:28
pues esa clase 00:17:29
si la hacemos como clase interna por comodidad 00:17:32
pues 00:17:36
será la clase para el botoncito 00:17:37
y tiene que 00:17:39
implementar ActionListener 00:17:41
porque el evento que debemos capturar es hacer clic 00:17:43
si fuera otro evento 00:17:45
relacionado con el ratón, con el teclado 00:17:46
con que el botón gane el foco o no lo gane 00:17:50
pues sería MouseListener, KeyListener 00:17:52
FocusListener 00:17:54
pero este es el por defecto, hacer clic 00:17:55
pues entonces ActionListener 00:17:57
sin complicaciones 00:17:59
vale, y ahora 00:18:02
si implementamos ActionListener 00:18:05
pues ya sabemos que 00:18:07
tenemos que implementar 00:18:08
este evento, y este evento 00:18:11
justo es lo que queremos que pase 00:18:13
cuando 00:18:15
cuando se dé al botón 00:18:16
vale, pues cuando se dé al botón entonces 00:18:19
¿qué queremos que ocurra? cuando se dé al botón 00:18:21
queremos que se cojan 00:18:23
los datos de una película 00:18:25
en este caso serían solo título y director 00:18:27
pero podrían ser más 00:18:29
y esa película quede guardada 00:18:31
entonces ahí ya tengo que empezar a hacer una primera 00:18:33
decisión que esta ya sí que es importante 00:18:35
porque lo que hemos hecho hasta ahora 00:18:37
es el front que se llama 00:18:38
me echo mi aspecto, eso es una tontería 00:18:40
eso es decido, arrastro 00:18:43
y pego, nada más 00:18:45
ese es el front 00:18:47
ahora viene el back, esas son ya las decisiones que cuenta 00:18:48
las que definen 00:18:52
cómo funciona tu aplicación, etc 00:18:53
vale, pues entonces aquí tenemos 00:18:55
la primera decisión de Bach, interesante 00:18:57
que es, vale, yo voy a tener que guardar películas 00:18:59
como lo hago, que diseño 00:19:01
hago, hombre, pues mira 00:19:03
vamos a hacer una clase película para guardarlo 00:19:05
porque si no, ¿qué hago? 00:19:07
guardo los títulos en un list de títulos 00:19:09
los directores en un list de directores 00:19:10
bueno, en este caso, como salen dos campos, podríamos 00:19:13
hacer un map que guarde 00:19:15
la clave, el título 00:19:17
el director, el valor 00:19:18
pero entonces no puede haber dos películas 00:19:20
que se llamen igual, o sea, dos directores 00:19:23
no podrían hacer dos películas con el mismo nombre 00:19:25
claro, si no va a ser ese el caso 00:19:27
pues no hay ningún problema 00:19:31
y por otro lado 00:19:33
si vamos a tener, si esta aplicación 00:19:36
se extiende, llega un momento en que me dicen 00:19:37
oye que extiende la aplicación 00:19:39
pero ahora quiero que de la película me guardes 00:19:41
año, intérpretes, patatín 00:19:43
pues entonces ya tengo que 00:19:45
rehacer mucho la aplicación, ya el map se me 00:19:47
descoloca, muchísimo mejor si me hago una clase 00:19:49
película, me hago una clase película 00:19:51
y así si la aplicación la extiendo le añado una propiedad 00:19:53
a la clase y ya está 00:19:55
pero ese muchísimo mejor 00:19:57
lo digo entre comillas y con matices 00:19:59
son decisiones de diseño 00:20:02
que dependen de todo el 00:20:03
contexto en el que esté trabajando 00:20:06
uno y con quien esté trabajando y quien lo vaya a usar 00:20:08
son muchísimo mejor a coger con pinzas 00:20:10
¿vale? pero bueno 00:20:12
en general, vamos a guardar datos de películas 00:20:14
pues parece de cajón 00:20:16
hacer una clase película 00:20:18
¿no? pues venga 00:20:20
vamos a hacer una clase película 00:20:22
entonces yo aquí lo estoy metiendo en el mismo paquete 00:20:23
porque los estoy separando por ejercicio 1, 2, 3 00:20:29
o lo que sea para luego subirlo 00:20:31
pero idealmente iría en otro paquete 00:20:33
en un paquete iría la vista, en otro iría 00:20:35
los métodos a los que llaman los capturadores, etc 00:20:36
vale, pero nos hacemos 00:20:39
una clase película 00:20:43
con dos propiedades 00:20:46
el título 00:20:48
y el director, bueno, como vamos van a ser string 00:20:56
Por ahora son las únicas dos propiedades 00:21:06
Pero esto ya se podría extender a más 00:21:10
Sin un momento dado la aplicación 00:21:12
Hay que escalarla a que las películas 00:21:13
Tengan más datos 00:21:15
Pues nada, los dos constructores 00:21:16
Para facilitarnos 00:21:21
El trabajo 00:21:22
Y GetDeset 00:21:24
Vale, bueno pues ya la clase película está 00:21:38
Entonces ahora 00:21:56
Volvemos a nuestra aplicación 00:21:57
Porque estábamos en el evento 00:21:59
Del botón 00:22:01
que es 00:22:02
este elemento del botón 00:22:04
y que hacíamos aquí 00:22:06
crear una película nueva 00:22:07
con los datos de la aplicación 00:22:10
y ahora habrá que decidir esa peli 00:22:12
donde la guardamos 00:22:14
pero ya crear la película lo podemos hacer 00:22:16
entonces 00:22:19
pues lo primero 00:22:20
que ocurra cuando 00:22:23
le demos al botón 00:22:24
será crear el objeto película 00:22:27
con los datos 00:22:29
que están en las áreas de texto 00:22:32
pues 00:22:33
título era el área de texto 00:22:36
punto gettest 00:22:38
y director punto gettest 00:22:40
vale, entonces 00:22:45
he cogido directamente 00:22:48
lo que hay en las áreas de texto con el gettest 00:22:50
como título 00:22:52
está declarada fuera 00:22:55
del constructor 00:22:58
está declarado fuera, es variable de clase 00:23:00
como está declarado fuera 00:23:02
puedo acceder aquí sin problema a él 00:23:03
si estuviera declarado local al constructor 00:23:06
no podría, pero lo he declarado 00:23:09
fuera precisamente porque iba a necesitar 00:23:11
acceder desde la capturadora 00:23:14
ah, ya tengo mi película 00:23:15
ahora, siguiente decisión 00:23:17
bueno, pues tengo que resolver 00:23:19
dónde van esas películas porque 00:23:21
tienen que estar ahí almacenadas durante todo 00:23:23
el tiempo de vida de la aplicación, porque la aplicación 00:23:25
trabaja con ellas, las consulta 00:23:27
a través del combo box, tienen que 00:23:30
estar en algún lado 00:23:31
lo ideal pues sería, la enchufo 00:23:32
una base de datos, pero claro, no sabemos enchufar 00:23:35
una base de datos, pero sí podemos 00:23:37
habilitar una colección para que se guarden 00:23:39
las películas. Bueno, pues 00:23:41
una colección, la más 00:23:43
sencilla que se nos ocurre para que se guarden las películas 00:23:45
pues podría ser una 00:23:48
lista, ¿vale? Una lista de películas 00:23:49
y si no, podría ser un set 00:23:52
entonces 00:23:53
¿qué nos hace decidir si es una lista 00:23:54
o un conjunto? 00:23:57
Los duplicados, ¿verdad? 00:24:00
Si queremos que haya duplicados o no queremos que haya 00:24:02
duplicados 00:24:05
porque si yo no voy a meter 00:24:05
nunca una misma película 00:24:08
dos veces, pues entonces puedo usar 00:24:09
un set, que el set 00:24:12
la complejidad interna de uso 00:24:13
para Java es mejor 00:24:16
entonces es más eficiente 00:24:18
para nosotros es lo mismo, es hacer 00:24:19
un add a la colección 00:24:22
un remove, es lo mismo, nos da igual 00:24:23
a efectos de programación, nos da igual un list que un set 00:24:25
porque se usan igual 00:24:28
pero las implicaciones 00:24:29
que tienen a nivel computacional 00:24:32
pues el set es más eficiente, pero a cambio 00:24:34
no puedo meter duplicados 00:24:36
entonces 00:24:37
ahora entraríamos a la siguiente pregunta 00:24:39
¿qué significa duplicados? 00:24:41
¿cuál es mi clave primaria de las pelis? 00:24:44
esto de nuevo son decisiones que no es que tengan 00:24:45
una respuesta universal 00:24:48
tienen una respuesta en el contexto 00:24:50
de la aplicación y para cada aplicación 00:24:52
tendrán una, entonces yo en la aplicación 00:24:54
en la que estoy, con el que me la ha pedido me dice 00:24:56
a ver 00:24:58
¿puede haber dos pelis con el mismo título? 00:24:58
pues sí 00:25:02
Puede haber dos directores que hayan hecho dos pelis 00:25:03
Que se llaman igual, no pasa nada 00:25:07
Puede haber dos directores que hayan hecho dos pelis que se llaman igual 00:25:08
¿Puede haber un director que pueda hacer dos pelis? 00:25:11
Pues sí, un director puede hacer dos pelis 00:25:16
Entonces en función de lo que nos responda 00:25:18
Si nos responde eso 00:25:19
La clave primaria de las películas sería doble 00:25:22
La clave primaria sería doble 00:25:28
Sería la combinación de título y director 00:25:31
¿Vale? 00:25:33
Entonces eso es lo que también estáis trabajando 00:25:36
En bases de datos 00:25:38
Hay que decidir cuál es la clave primaria 00:25:38
Que mejor representa 00:25:42
Un modelo de datos 00:25:44
Entonces aquí habría que aclararlo 00:25:45
Con el que nos lo dijera 00:25:48
Oye, para ti la unicidad de las pelis 00:25:49
¿Cuál es? 00:25:52
El título, el director 00:25:53
La combinación de ambos 00:25:56
La del director no tiene sentido 00:25:58
pero lo normal es que un director haga varias películas 00:25:59
la del título 00:26:01
podría tenerlo, pero hombre 00:26:03
habría que aclarar, oye, a ver 00:26:05
¿pueden dos directores repetir peli? 00:26:07
repetir título, perdón 00:26:10
bueno, en función de lo que nos diga, decimos 00:26:11
la clave primaria 00:26:13
¿vale? 00:26:14
pero aquí, ¿qué ocurre en esta aplicación? 00:26:17
que si el tío me dice, no, no, claro que pueden dos 00:26:19
directores hacer una peli al mismo título 00:26:21
pues entonces nos ha planteado 00:26:23
la aplicación muy mal 00:26:25
porque entonces nosotros que estamos analizándola 00:26:26
y no se nos escapa ningún detalle 00:26:29
porque el que nos pide la aplicación se le escapan 00:26:31
mil detalles, porque él quiere algo 00:26:33
y lo normal es que nunca tenga las ideas claras 00:26:35
y te dice, yo quiero que me hagas esto, que haga no sé qué 00:26:37
entonces, el trabajo 00:26:39
del desarrollador 00:26:41
es poner en orden 00:26:43
las ideas confusas que tiene esa persona 00:26:45
que te está pidiendo el software y que seguramente 00:26:47
te está diciendo cosas incoherentes, por ejemplo 00:26:49
aquí rápidamente diríamos, a ver, vamos a ver 00:26:51
si aquí van a ir 00:26:53
los títulos y por título 00:26:55
yo voy a poder seleccionar peli para ver director 00:26:57
no me puedes decir 00:27:00
que dos directores 00:27:01
puedan hacer una peli con el mismo nombre 00:27:04
entonces cuando yo selecciono aquí Harry Potter 00:27:05
si dos directores han hecho una peli que se llama Harry Potter 00:27:07
¿a cuál te pongo aquí? 00:27:10
entonces ahí ya no sé 00:27:13
habría estado dando un requisito mal 00:27:14
que es lo habitual 00:27:15
bueno pues entonces o se cambia la aplicación 00:27:16
para que sea director 00:27:20
es que lo han hecho, lo vamos a hacer 00:27:21
entonces la clave primaria tiene que ser 00:27:22
el título 00:27:25
¿verdad? entonces ese análisis 00:27:26
ese análisis ya habría avanzado 00:27:29
un poco para dar forma a la aplicación 00:27:31
que nos han pedido 00:27:33
bueno, entonces lo que de alguna manera quiero deciros 00:27:34
es que hay que pensar mucho 00:27:37
antes de escribir, antes de poner 00:27:39
soluciones, antes de... porque hay que tener muy muy 00:27:41
claro qué se quiere hacer 00:27:43
y sobre todo cuáles son 00:27:45
los requisitos, las condiciones de trabajo 00:27:47
bueno, pues todo esto venía 00:27:49
a cuento de qué decidir, si una lista 00:27:51
y un conjunto, vale 00:27:53
ya hemos dado un paso grande 00:27:55
que es decidir cuál es la clave primaria 00:27:56
de la aplicación, películas 00:27:59
título, perdón, y ahora 00:28:01
vamos a admitir meter la misma 00:28:02
película varias veces 00:28:05
si la aplicación lo necesita 00:28:06
no nos queda más remedio que una lista 00:28:11
pero hombre, esta aplicación 00:28:13
en principio no lo necesitas para meter películas 00:28:15
y según yo las tengo metidas, pues ya van ahí 00:28:17
a la colección y ya está, y una vez que he metido una peli 00:28:19
no la tengo que meter una segunda vez 00:28:21
No parece que sea necesario que una peli esté dos veces metida, ¿no? La misma peli esté dos veces en posiciones distintas de la lista. No parece necesario. Podría serlo en otra aplicación que pidiera otras cosas, pero en esta no lo parece. Bueno, pues podríamos meterlo en un set. Ya está. 00:28:23
pues todo esto es para tomar una decisión 00:28:41
que parece trivial y en una aplicación 00:28:43
pequeña como esta, uno la puede tomar 00:28:46
rápidamente, pero en una aplicación 00:28:47
grande, uno no la toma rápidamente 00:28:49
estas decisiones, las tiene que tomar 00:28:51
muy concienzudamente, porque si no 00:28:53
la aplicación va a ir bien 00:28:56
o va a ir fallando de manera 00:28:57
que no sabes por qué y al final tienes que rehacer 00:28:59
de cero desde el principio 00:29:01
bueno, pues en nuestro caso si hemos hecho el análisis 00:29:02
más o menos con sentido, hemos decidido 00:29:05
que un set, vale, pues esta peli va a ir a un set 00:29:07
ese set, ¿dónde lo ponemos? 00:29:09
pues tiene que ir a un sitio que sea accesible 00:29:12
desde aquí, lógicamente 00:29:14
desde aquí y desde 00:29:15
seguramente más sitios 00:29:18
entonces, hombre, pues podríamos 00:29:20
poner el set aquí 00:29:22
vale, lo que pasa es que eso es feo 00:29:23
lo podemos poner ahí, ya está 00:29:26
pero bueno, eso es feo a nivel 00:29:27
de diseño porque en realidad 00:29:30
esta clase es mi vista 00:29:32
esta clase se refiere a 00:29:33
toda la parte de código que me construye 00:29:35
que entonces poner aquí 00:29:38
el set, bueno, lo ideal sería 00:29:40
que todo relacionado con los datos vaya en una clase 00:29:42
aparte, pues venga, vamos a 00:29:44
hacerlo un poquito mejor 00:29:46
vamos a hacer aquí una clase 00:29:48
que se llame datos 00:29:50
y aquí van a ir los 00:29:52
datos 00:29:56
pues venga, hemos 00:29:56
dicho que en un set, pues en un set 00:30:01
ya de paso lo instanciamos 00:30:03
pues venga, ¿qué tipo de set? 00:30:10
bueno, vamos a 00:30:11
nos viene bien que cuando 00:30:12
yo itere por las pelis aparezcan ordenadas 00:30:15
alfabéticamente o de alguna manera 00:30:17
pues si 00:30:19
nos da igual, un haset 00:30:21
si nos viene bien que aparezcan ordenadas 00:30:23
cuando yo itero un triset 00:30:25
¿vale? porque recordad 00:30:27
que el triset en la iteración 00:30:29
te lo monta por orden alfabético 00:30:31
el haset, la iteración 00:30:33
te la va sacando 00:30:35
por criterios 00:30:36
que no tienen por qué ser el orden 00:30:39
de los objetos 00:30:40
Vale, pues un headset 00:30:43
Suele ser una opción habitual 00:30:46
Para trabajar con conjuntos 00:30:48
Vale, pues ahora aquí ya 00:30:51
En mi este de aquí 00:30:56
Ya podemos añadir 00:30:57
A los datos 00:30:59
La película 00:31:03
Datos.ad 00:31:05
Película 00:31:11
Uy, que susto que te habías dado 00:31:15
Vale 00:31:18
Uy, datos.ad 00:31:23
Película, que hago yo 00:31:27
datos.peliculas 00:31:28
se llama 00:31:31
.adpelicula 00:31:32
vale, este es mi set 00:31:37
de pelis, variable estática 00:31:40
de la clase, accesible desde cualquier lado 00:31:43
añado la película 00:31:44
vale, esta parte está hecha 00:31:45
¿hasta aquí vamos bien? 00:31:49
¿quién ha dicho sí? 00:31:52
¿tú has dicho sí, Diego? 00:31:56
pues vamos fatal 00:31:57
vamos muy mal 00:31:59
pero admirable que al menos 00:32:01
contestes 00:32:04
eso te lo reconozco 00:32:05
vamos fatalísimo porque estamos 00:32:07
metiendo en un hash set 00:32:10
un objeto 00:32:12
de una clase 00:32:14
que ni hasco, ni igual, ni la madre 00:32:15
que lo trajo, con lo cual ya vamos mal 00:32:18
¿vale? 00:32:20
entonces desde el momento en el que hemos decidido 00:32:21
que las pelis 00:32:24
las pelis van a ir a un hash set 00:32:25
para que 00:32:28
los métodos que llama el hash set 00:32:30
funcionen correctamente por dentro 00:32:32
película tiene que tener el jasco de equals 00:32:34
porque si no 00:32:36
eso de igualdad de pelis por título 00:32:37
que hemos dicho, eso no 00:32:40
se va a dar, no va a haber 00:32:42
ni una sola película igual a otra, porque la igualdad 00:32:44
va a ser por dirección de memoria 00:32:46
entonces que queremos eliminar una peli 00:32:47
esta aplicación no tiene la misma 00:32:50
la funcionalidad de eliminar películas 00:32:52
pero podría tener un botoncito aquí abajo 00:32:54
que fuera eliminar peli 00:32:56
entonces si yo le doy a eliminar 00:32:57
y no tengo el jasco de equals, pues se me complica 00:32:59
la vida porque no puedo usar el remove 00:33:02
voy a tener que iterar, voy a tener que hacer 00:33:03
una movida, no puedo hacer el remove 00:33:06
entonces vamos mal 00:33:07
si no ponemos el jasco de equals en película 00:33:09
pues venga, y aquí es donde 00:33:12
viene la pregunta, en la fase de análisis 00:33:18
acordamos y acordamos bien 00:33:20
y con criterio, no a lo tonto 00:33:22
¿cuál era nuestra clave primaria? 00:33:24
sí, la acordamos muy bien, era el título 00:33:26
vale, y la acordamos 00:33:28
porque si no 00:33:30
la interfaz no tenía sentido, si había un combo box 00:33:31
en el que yo podía solucionar por título 00:33:34
no tenía sentido que la clave primaria no fuera 00:33:36
solo el título 00:33:38
pues ahora nos hacemos el jasco de equals 00:33:39
con esa clave primaria que habíamos decidido 00:33:42
venga, ya está 00:33:44
ahora ya 00:33:47
así que vamos bien 00:33:49
vale, ya hemos añadido la película 00:33:50
pero nos falta 00:33:52
nos falta que hemos dicho 00:33:55
que además de añadir película 00:34:00
yo, ala, ahora ya está añadida 00:34:02
pero nos falta que el combo box 00:34:07
se actualice recibiendo ese nuevo título 00:34:09
esto nos falta 00:34:11
bueno, pues entonces ahora es cuando 00:34:12
buscamos en los métodos de ese objeto 00:34:15
que yo he buscado, el combo box 00:34:17
buscamos en los métodos a ver si hay alguno 00:34:19
que por nombre me suene 00:34:21
a incorporar un nuevo elemento 00:34:23
o busco en los 00:34:25
métodos a ver que me suena 00:34:27
o me voy directamente a la documentación 00:34:28
y lo busco, que siempre sería lo más seguro, claro 00:34:31
vosotros en vuestro caso, pues se lo preguntaríais 00:34:33
a HGPT, pero 00:34:37
así no aprenderíais 00:34:38
Vale, pues venga 00:34:40
El combo box, ¿cómo se llamaba? 00:34:43
Se llamaba 00:34:45
Se llamaba lista películas 00:34:45
Pues venga, lista películas 00:34:51
Lista películas 00:34:56
Vamos a ver qué puedo hacer yo con un combo box 00:35:06
Qué puedo hacer 00:35:08
Añadir un componente 00:35:09
Pero add, bueno, add 00:35:12
Sí, add se parece a lo que yo quiero 00:35:14
Pero es añadir componente 00:35:16
Esto es medio raro 00:35:18
entonces 00:35:19
la única en la que en realidad 00:35:21
me aparece añadir un objeto cualquiera 00:35:28
es add item 00:35:30
entonces hombre, aquí lo normal es que 00:35:32
uff, no tengo yo muy claro 00:35:34
cuál será 00:35:36
uno lo busca en la ayuda, lo busca y en medio 00:35:37
segundo dice, ah, lo que yo estoy buscando es 00:35:40
add item 00:35:42
¿vale? pues venga 00:35:43
añade un nuevo item 00:35:46
a tu desplegable 00:35:48
Vamos a añadir un nuevo ítem 00:35:49
Y que 00:35:51
A ver, vamos a cerrar esto 00:35:53
Y que quiero añadir yo aquí 00:35:56
Quiero añadir el título de la película 00:35:59
Porque eso es lo que quiero 00:36:00
Que me aparezca en 00:36:01
Película.getTítulo 00:36:02
Eso es lo que quiero que me aparezca 00:36:05
Vale 00:36:07
Vale, aquí de nuevo 00:36:08
Me aparece esto en amarillo 00:36:11
Eso de nuevo es una especie de 00:36:12
Cosa que me dejo ahí apuntada 00:36:16
Esto que me dice 00:36:17
Igual tendría que tenerlo en cuenta 00:36:19
Me dice que ComboBox 00:36:20
Mejor si la parametrizo 00:36:21
Ahora volvemos sobre ello 00:36:23
Por ahora vamos nosotros resolviendo 00:36:25
Sobreviviendo a la aplicación 00:36:27
A ver 00:36:28
Vale, vamos a ver si esta parte del botón 00:36:29
Ya hace lo que tiene que hacer 00:36:33
Eso es lo siguiente 00:36:35
La parte del botón yo creo que ya está toda 00:36:35
Vamos a ver si la parte del botón 00:36:37
Hace lo que tenía que hacer 00:36:39
Entonces 00:36:43
Pues venga, esta es mi aplicación 00:36:45
Venga, vamos a añadir una película 00:36:56
Pepito que dirigió 00:36:58
La luna 00:37:01
Añadir peli 00:37:03
Pues aquí no ha añadido la película 00:37:05
¿Vale? 00:37:08
¿Qué puede habernos pasado? 00:37:11
Para haber cometido este fallo que digo 00:37:12
Pero como puede ser, si yo lo he hecho todo bien 00:37:14
¿Qué nos puede haber pasado? 00:37:16
¿Vale? 00:37:18
Os voy a repasar el código de espacio de arriba a abajo 00:37:19
Yo tengo aquí mi constructor 00:37:22
Ahí está construida la interfaz 00:37:24
Tengo aquí la capturadora 00:37:27
No era asociar el evento al botón 00:37:29
Efectivamente 00:37:36
¿Vale? 00:37:38
Entonces 00:37:43
Botón 00:37:43
Toda esta serie de 00:37:44
Despistes y cosas 00:37:47
Que se hacen continuamente 00:37:49
Que no se hagan perder el tiempo 00:37:51
Que no se hagan ya rápidamente 00:37:53
La primera vez que uno lo comete ya lo automatiza 00:37:55
Pero tenéis que automatizarlo para que no se hagan perder el tiempo 00:37:58
Sobre todo un examen 00:38:00
Pues nada 00:38:02
al botoncito, le añadimos el ActionListener 00:38:03
New 00:38:06
y se llama Captura Botón 00:38:06
vamos a volver a probar 00:38:09
vale, pues venga 00:38:20
vamos a ver si Pepito que dirigió 00:38:33
lo estoy haciendo al revés, la luna 00:38:35
que la dirigió Pepito 00:38:37
se me añade 00:38:39
vale, ya tengo ahí una peli 00:38:42
venga, y vamos a ver 00:38:44
si esta otra peli 00:38:47
Que dirigió Juanito 00:38:48
Pues sí, vale, ahí está 00:38:51
Añadida 00:38:53
Vale, entonces uno ya podría 00:38:55
Jugar con esto, hacer mil cosas 00:38:57
Decidir en qué orden aparecen 00:38:59
Ahí, bueno, mil historias 00:39:01
Pero todo esto ya es investigación 00:39:03
Vale, bueno, pues esta parte ya está 00:39:05
¿Qué parte nos falta? Este 00:39:06
Bueno, le he dado aquí tantas veces que me ha aparecido 00:39:09
Tropecientas mil veces en el 00:39:11
Combo Box, con lo cual aquí 00:39:15
Aquí he tenido 00:39:16
Esto es un error de la aplicación, ¿verdad? 00:39:20
O sea, esto cuando uno hace la prueba 00:39:22
Esto a lo mejor lo ha hecho uno y lo pasa a la fase de pruebas 00:39:23
Y cuando uno hace la prueba me dice 00:39:25
Eh, oye, ¿no habíamos quedado que el sol era clave primaria? 00:39:27
Perdona, pues no añadas al combo box 00:39:32
Un título que ya está 00:39:34
Entonces yo esto lo he hecho muy alegremente 00:39:35
Entonces esto sería un bug 00:39:37
Que hay que arreglar, ¿verdad? 00:39:39
Esto es algo que saldría en la fase de pruebas 00:39:41
Cuidado, que yo lo estoy dando aquí 00:39:43
entonces 00:39:45
este 00:39:48
add item de aquí 00:39:55
este add item de aquí 00:39:58
no tiene que ser 00:40:00
incondicional 00:40:01
tiene que ser 00:40:04
añade esta película al combo box 00:40:06
si no está previamente 00:40:09
si no está previamente 00:40:10
¿vale? entonces 00:40:12
esto lo dejo aquí 00:40:14
para que sea un problema que resolváis 00:40:21
vosotros 00:40:23
si no metemos el mismo título la aplicación funciona igual 00:40:24
funciona bien, lo dejo aquí para que 00:40:27
sea un problema que se os quede planteado a vosotros 00:40:29
como resolveríais, vale 00:40:31
y ahora resuelto ese problema 00:40:32
de mal funcionamiento de la aplicación 00:40:34
nos quedaría el evento 00:40:37
de el combo box 00:40:38
vamos a parar un momentito y lo 00:40:40
hacemos luego 00:40:42
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
6 de mayo de 2024 - 19:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
172.13 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid