Saltar navegación

Clase 30-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.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues vamos a hacer el proceso de toda la vida, reproducirlo para los que estén un poquito más verdes, ¿vale? 00:00:00
Bueno, pues entonces, aquí es una única ventanita, un frame con tres componentes, ya está, nos los dan hechos. 00:00:10
Por estos tres componentes, una etiqueta, un text field y un botón, los podemos hacer con el worldview builder tranquilamente, sin ningún problema. 00:00:20
entonces ya hacemos lo de siempre 00:00:30
vamos a hacer 00:00:32
una nueva clase 00:00:33
no, vamos a aprovecharnos del plugin 00:00:36
pues aquí abrimos 00:00:38
y nos vamos a window builder 00:00:40
vamos a 00:00:42
dentro de swing designer 00:00:45
un frame, este frame 00:00:47
uno lo llama como le dé la gana 00:00:53
ventana, vale 00:00:55
fase de colocar los componentes 00:01:02
que están siempre todo el rato 00:01:04
ahí durante la ejecución de la aplicación. 00:01:06
Esa fase, venga, nos la ahorramos 00:01:09
haciéndola con la pestaña de diseño 00:01:13
porque va a ser más rápida. 00:01:15
Pues ala, ¿qué componente es primero? 00:01:18
Selecciono panel, le pongo al panel 00:01:20
el gestor de ubicación absoluto. 00:01:23
Lo que es lo mismo, no hay gestor de ubicación. 00:01:26
Recordad que esto se habrá traducido, 00:01:30
el ponerle layout absoluto, 00:01:32
se habrá traducido a esta línea, que al panel setLayout null, es decir, ningún gestor de ubicación. 00:01:34
Si no hay ningún gestor de ubicación, cada componente que añadamos con el add, 00:01:43
hay que decir en qué coordenadas está colocado, porque como no hay gestor de ubicación, 00:01:47
hay que decir en qué coordenadas está. 00:01:52
Como ya lo tenemos en layout null, vamos a añadir los componentes, 00:01:55
como son componentes 00:02:01
pues los busco dentro de aquí 00:02:03
de componentes 00:02:05
una etiqueta 00:02:05
que la ponemos aquí mismo 00:02:08
que la etiqueta decía 00:02:11
pulsa el botón 00:02:12
y elige ruta 00:02:15
pues ya está, la seleccionamos para cambiar la propiedad 00:02:16
la propiedad, el texto 00:02:19
lo ponemos aquí 00:02:21
pulsa el botón 00:02:23
y elige ruta 00:02:27
ala 00:02:29
Nombre de la variable 00:02:32
Nos ha ofrecido 00:02:34
Este nombre tan horrible 00:02:37
Es el nombre que va a dejar 00:02:38
A esta variable si no se lo cambiamos 00:02:41
Este nombre horroroso 00:02:43
Entonces este nombre horroroso no lo queremos 00:02:45
Pues vamos a cambiar el nombre de la variable 00:02:47
Pues cualquier cosa 00:02:49
Esta etiqueta realmente 00:02:51
No vale para nada porque 00:02:54
Está ahí todo el rato 00:02:55
Está ahí quieta, no le vamos a cambiar su contenido 00:02:57
Ala 00:03:00
Ala, ya está 00:03:00
Ahora, ¿qué más componentes nos faltan? 00:03:03
Pues un textfield que va debajo 00:03:05
Para recoger una ruta 00:03:07
Ahí está ese textfield 00:03:11
Nombre de la variable 00:03:15
Hombre, pues este nombre es muy feo 00:03:17
Se lo cambiamos 00:03:19
Texto ruta 00:03:20
El que os sea explicativo a vosotros 00:03:23
Ala, ya está 00:03:25
¿Veis? Aquí por ejemplo 00:03:27
En las propiedades aparecen mil cosas 00:03:33
Esto es 00:03:35
El tamaño del textfield 00:03:36
Y las coordenadas en las que está 00:03:39
coordenada X, 74, coordenada 00:03:40
Y, 97, yo se la podría cambiar 00:03:42
¿me deja cambiarla desde aquí? 00:03:45
sí, ¿veis? coordenada 00:03:47
X, si yo se la cambio y le pongo aquí 00:03:48
100, pum, se me va a mover 00:03:50
efectivamente 00:03:52
se me ha ido, pam, hacia allá 00:03:54
se me da a la derecha 00:03:56
si yo lo vuelvo a mover desde aquí 00:03:57
pues, ¿veis? me aparecen 00:04:00
en el desplegable las coordenadas 00:04:02
en las que los está colocando 00:04:04
74, 97, ahí lo dejo 00:04:05
entonces 00:04:08
el conocer las coordenadas 00:04:10
el ver cómo acceder a ellas 00:04:12
tiene interés porque cuando uno hace 00:04:14
un diseño 00:04:16
muy preciso con un montón de componentes 00:04:18
a veces es que tiene que ir 00:04:20
coordenada por coordenada asegurándose de que 00:04:21
la coordenada X de todos es la 74 00:04:24
la Y de todos es la 20 00:04:26
entonces el conocimiento de las coordenadas 00:04:28
es importante a veces 00:04:31
me aparece ahí cuando yo lo muevo 00:04:32
me aparece en qué coordenadas estoy colocando 00:04:34
vale, pues ahí lo dejo 00:04:36
¿y qué nos falta? un botón 00:04:40
pues cogemos el botón 00:04:41
que va ahí 00:04:43
lo voy a poner debajo 00:04:44
el texto del botón 00:04:47
en lugar de new button que sean 00:04:49
tres puntitos, pues hala, tres puntos 00:04:51
voy a ponerle más puntos para que se vea más 00:04:53
y el nombre de la variable 00:04:55
el nombre de la variable ese es horroroso 00:04:59
pues lo voy a llamar 00:05:00
yo que sé, botón como solo hay uno 00:05:03
hala y mi interfaz ya está 00:05:05
ahora podríamos hacer una simulación 00:05:08
a ver tiene el aspecto que queremos 00:05:11
dándole al botoncito 00:05:12
pues sí, tiene el aspecto que quiero 00:05:13
¿vale? 00:05:16
ahora ya 00:05:18
comportamiento 00:05:19
de esta interfaz 00:05:21
el único componente 00:05:24
que va a recibir un evento 00:05:26
y que va a generar respuesta 00:05:28
el único es el botón 00:05:30
pues un único ActionListener para ese botón 00:05:31
de nuevo 00:05:34
o me hago una clase interna 00:05:36
sobre escribo 00:05:38
el método ActionPerformat 00:05:40
y pongo ahí lo que quiera 00:05:42
o como ya sé cómo hacerlo, ya entiendo la estructura 00:05:43
perfectamente 00:05:46
pues me aprovecho del builder 00:05:46
me aprovecho del builder 00:05:49
y hago, oye 00:05:52
que yo lo que quiero es en este componente 00:05:53
quiero añadir un manejador de eventos 00:05:55
y además quiero 00:05:57
en particular 00:06:00
capturar este método 00:06:01
porque sabemos que este es el método del ActionListener 00:06:03
y el evento del botón es el por defecto 00:06:06
luego es ActionListener 00:06:08
vale, pues me aprovecho, selecciono 00:06:09
Botón derecho, este es el que yo quiero 00:06:11
Y ya está 00:06:13
Y ya se me va 00:06:16
A esta parte del código 00:06:17
Añade al botón un Action Listener 00:06:19
Efectivamente lo añade 00:06:22
Y me dice, venga pues 00:06:23
Sobrescribe la acción performance que tú quieres 00:06:26
Y aquí ya es 00:06:27
Donde nos viene que 00:06:30
Es justo ahí, en ese momento 00:06:31
Y solo ahí, cuando queremos que se abra 00:06:33
Una emergente, solo ahí 00:06:36
¿Vale? Entonces 00:06:38
la ventana emergente, repito 00:06:40
no la tenemos que colocar con el builder 00:06:42
pero es que ni está, la ventana 00:06:44
emergente es una cosa que ocurre 00:06:46
no una cosa que se ve 00:06:47
entonces una aplicación con interfaz gráfica hay que distinguir 00:06:49
lo que yo veo ahí siempre 00:06:52
de forma estática y eso ya sí que lo 00:06:54
puedo ir colocando y fijando y las cosas 00:06:56
que ocurren de forma dinámica 00:06:58
como que se abra una ventana 00:07:00
pues eso lo tengo que hacer por código 00:07:01
pues aquí tendré que hacer por código 00:07:03
que se abra una ventana 00:07:06
para permitirme seleccionar un archivo 00:07:07
claro, afortunadamente ya hay una clase 00:07:09
que tendrá algún método que te permite hacer eso 00:07:13
porque si no es complicadísimo programar eso 00:07:16
es como el jOptionPane famoso 00:07:19
si yo quiero programar aquí un montón de sentencias 00:07:21
para que se me abra una ventanita de mensaje 00:07:24
pues hacer eso es una locura 00:07:26
menos mal que tenemos la clase jOptionPane 00:07:28
con un método estático que lo hace todo 00:07:30
pues con la ventana que me abre un explorador de archivos 00:07:32
pues lo mismo, menos mal que ya hay una clase 00:07:37
que ya tiene métodos para hacerlo 00:07:40
entonces, como yo ya sé el nombre 00:07:41
de esa clase, porque me lo han 00:07:44
dicho y si no me lo han dicho lo busco 00:07:46
como ya lo sé, pues ahora ya averiguo 00:07:47
me voy a la documentación, me voy a la 00:07:50
API de Java, la API de Java es 00:07:51
la información sobre los métodos que tiene la máquina virtual 00:07:53
me voy a ella 00:07:56
y miro a ver cómo se usa 00:07:57
y ya está 00:07:59
¿vale? pero he llegado a este 00:08:00
punto haciendo lo más importante 00:08:04
que es saber 00:08:06
cuándo y dónde 00:08:07
tengo que usar eso y cómo y de qué manera 00:08:09
cuando ya tengo la estructura de mi aplicación hecha 00:08:11
y ya he llegado a lo más importante 00:08:13
que es, ojo, que los 00:08:15
métodos de este file chooser para abrir la ventana 00:08:17
su sitio es este 00:08:19
eso es lo más importante 00:08:21
aquí es donde tengo yo ya que instanciar 00:08:23
ese objeto para que funcione y se abra 00:08:26
toda esa es la parte importante 00:08:28
que esa no está en ningún lado, esa no te la soluciona 00:08:29
nadie, ahora viene la parte chorra 00:08:31
que es, vale, voy a buscar la clase 00:08:33
JfileChooser, a ver cómo se usa 00:08:35
bueno, pues uno la busca 00:08:37
y verá, ah, pues tienes que instanciar 00:08:39
el JfileChooser, luego llamar al método 00:08:42
que sea, vale 00:08:44
entonces, por ejemplo, voy a copiar el código 00:08:45
que lo 00:08:48
tengo por aquí para no escribirlo 00:08:50
entero 00:08:52
vale, pues lo primero 00:08:52
hay que instanciar el objeto 00:08:56
vale, pues venga 00:08:57
instanciamos 00:08:59
el objeto 00:09:01
el objeto ya está instanciado 00:09:04
ahora, llamamos de ese objeto 00:09:06
al método 00:09:08
que se corresponda con abrir la ventana 00:09:10
que yo quiero 00:09:12
bueno, pues busco 00:09:13
vale, entonces uno busca aquí 00:09:15
a ver qué métodos hay 00:09:18
para abrir ventanitas 00:09:20
que te permitan acceder a archivos 00:09:22
pues 00:09:24
vale 00:09:26
uno 00:09:31
más que a ciegas 00:09:37
lo buscaría en la documentación 00:09:38
Pero ya solo con el nombre de los métodos 00:09:41
Ya entiende algo 00:09:43
Con el nombre de los métodos 00:09:46
Fijaos, aquí hay un método que es 00:09:48
Abre 00:09:53
Un diálogo para abrir 00:09:54
Esto es precisamente 00:09:57
Para abrir un diálogo 00:09:58
De abrir archivo 00:10:00
Este es uno para guardar 00:10:02
¿Vale? 00:10:07
Entonces 00:10:09
Vamos a probar el primero de ellos 00:10:09
Este 00:10:12
entonces, yo ahora estoy 00:10:18
como si estuviera trabajando a ciegas 00:10:23
probando sin más, uno no trabaja a ciegas 00:10:25
uno se mira la documentación, lo busca en algún sitio 00:10:27
y ya te 00:10:29
te va a decir cómo usarlo 00:10:30
yo ahora estoy trabajando a ciegas 00:10:34
¿vale? entonces 00:10:36
vale, entonces 00:10:38
hay que pasarle un objeto 00:10:52
el objeto es 00:10:54
el frame al cual está 00:10:56
asociado esa ventana, igual que el jOptionPane 00:10:58
que había que pasarle un objeto 00:11:01
y el mensajito, el objeto era el frame al que estaba asociado 00:11:02
si es el frame por defecto que me lo envuelve todo 00:11:05
pues le poníamos null, entonces uno podría hacer la primera prueba 00:11:09
a ver que me abre esto, a ver que me abre 00:11:11
entonces hacemos la primera prueba de esta aplicación 00:11:14
le doy al botón y efectivamente 00:11:17
ese show open dialog me abre 00:11:26
una ventanita con además que me permite a mi 00:11:29
elegir cosas 00:11:32
eso es lo que hace, abrirme eso 00:11:34
Que yo quiero 00:11:36
Vamos a probar la otra 00:11:40
La de show safe 00:11:44
La otra que había 00:11:47
A ver esta que te abre 00:11:47
Pues si probamos esto 00:11:50
Esta parece que es la misma 00:11:53
Pero no es la misma 00:11:56
Te ha cambiado lo que aparece en ese botón 00:11:57
En este botón te aparece guardar 00:12:00
No es que te vaya a guardar nada 00:12:02
Lo que te cambia es 00:12:04
Oye, esta ventanita 00:12:06
si tú la vas a usar para 00:12:07
guardar un archivo, que luego 00:12:09
tendrás que programarlo después, claro 00:12:11
esta te pega más porque te dice guardar 00:12:12
te dice eso, si tú la vas a usar 00:12:15
para abrir un archivo, que luego lo de abrir 00:12:17
le hemos dado, tendrás que programarlo tú 00:12:19
pues esta te dice abrir 00:12:20
que te pegará más, es la única diferencia entre ambas 00:12:23
el aspecto que tienen, la única diferencia 00:12:25
lo que pasa después 00:12:27
de que tú le des a los botones, eso tendrás que programar tú 00:12:29
no es que esta te abra 00:12:32
archivos ni te guarde ni nada 00:12:35
esto lo único que te hace 00:12:36
lo único que te hace es 00:12:38
abrirte la ventanita 00:12:40
abrirtela, ya está, lo que pasa 00:12:42
después de que tú la hayas cerrado 00:12:44
lo tendrás que programar tú 00:12:46
entonces claro, aquí ya surgen preguntas 00:12:47
uy, y cómo puedo recoger yo 00:12:50
cómo puedo recoger 00:12:52
yo la información que yo haya puesto 00:12:55
vale, cómo puedo 00:12:58
recoger yo, porque yo se supone que 00:13:14
esto lo he hecho para seleccionar algo y ponerlo 00:13:15
aquí, cómo puedo recoger yo 00:13:17
una vez que cierre esto 00:13:19
¿cómo puedo recoger yo esto que he metido aquí? 00:13:21
bueno, pues igual que el jOptionPanel 00:13:24
en el showInputDialog te lo devolvía 00:13:26
como valor de retorno 00:13:28
pues este te lo devuelve como valor de retorno 00:13:29
entonces simplemente se trata de 00:13:31
recoger el valor de retorno de esa ventanita 00:13:33
entonces 00:13:36
¿qué te devuelve 00:13:38
showOpenDialog? te devuelve un numerito 00:13:48
¿vale? 00:13:50
te devuelve un numerito 00:13:52
y ese numerito puede ser 00:13:53
o este de aquí 00:13:55
cancel option 00:13:57
o open option 00:14:00
en función de si le has dado al botón de cancelar 00:14:02
o al otro, te devuelvo un numerito 00:14:05
pues vamos a 00:14:06
primero de todo recoger ese numerito 00:14:07
aquí, vamos a recoger 00:14:12
este numerito 00:14:20
este numerito es lo que se ha pulsado en la 00:14:21
ventana, es decir 00:14:28
si se ha dado a guardar o cancelar, porque hay dos opciones 00:14:33
si se ha dado a guardar o a cancelar 00:14:36
si se ha dado a guardar, te devuelve un número 00:14:37
y se ha dado a cancelar te devuelve otro 00:14:39
y luego aparte de alguna manera tiene que haber 00:14:41
para coger esto 00:14:43
para coger este texto que hay aquí 00:14:45
de alguna manera tiene que haber 00:14:46
vale, pues entonces, primero 00:14:48
vamos a ver, si no se ha dado a la de cancelar 00:14:51
es lo que habría que hacer, ¿no? 00:14:54
si no hemos dado 00:14:55
si la opción esta 00:14:56
resulta que no es 00:14:58
si la opción 00:15:01
es diferente de la de cancelar 00:15:04
y la de cancelar 00:15:07
cancelar 00:15:09
es esta 00:15:09
cancel, la de aceptar sería la de approve 00:15:13
si no le hemos dado 00:15:19
a la de cancelar 00:15:21
en este caso 00:15:22
¿qué es lo que queremos? 00:15:25
pues querríamos 00:15:28
cancel 00:15:29
option 00:15:33
no he escrito bien 00:15:34
jfile chooser 00:15:39
bueno, ya se me pondrán 00:15:40
vale 00:15:57
vale, si no es 00:15:57
la de cancel option, ¿qué tenemos que 00:16:00
coger ahora? Tendremos que coger el 00:16:01
texto que se haya seleccionado 00:16:03
no, es que Carmen está con 00:16:05
vale, si no es la de cancelar, si yo 00:16:10
no he dado esta, sino que he dado esta, tendremos que coger 00:16:19
lo que se haya seleccionado aquí. ¿Y cómo 00:16:21
cogemos lo que se ha seleccionado ahí? Pues nos tendremos que ir 00:16:23
a la ayuda de esa clase, a ver de 00:16:25
dónde lo saco. Nos tendremos que ir a la ayuda. 00:16:27
Entonces uno se va a la ayuda, busca, 00:16:29
averigua y dice, ah, 00:16:31
vale, es que 00:16:33
el texto, el nombre 00:16:34
que yo haya seleccionado ahí, lo puedo 00:16:37
coger con este método. Lo puedo 00:16:39
coger con este método. Magnífico. 00:16:41
Vale. 00:16:45
Pues entonces 00:16:45
a ver 00:16:46
esta no es. 00:16:48
Bueno, pues entonces 00:16:55
si no es la opción de cancelar 00:16:56
me cojo 00:16:59
de aquí 00:17:02
get 00:17:03
selected 00:17:05
a ver si hay uno que no me 00:17:08
abriré a... 00:17:26
Vale, con esto me coge 00:17:35
el fichero que yo haya seleccionado. 00:17:40
y yo lo que quiero es la ruta 00:17:42
yo lo que quiero es la ruta, entonces sigo averiguando 00:17:44
ah, vale 00:17:47
pero es que la ruta de ese fichero 00:17:48
la puedo sacar con este método, getPath 00:17:50
me lo dice, y ahora 00:17:52
¿qué tengo que hacer con esto? fijarlo en el textField 00:17:54
fijarlo en el textField, ruta 00:17:56
pues a la 00:17:58
ruta.seqtext 00:18:02
texto ruta se llamaba 00:18:05
texto ruta 00:18:09
seqtest esto 00:18:20
ahora, bueno pues esto 00:18:21
sería sin particularizar 00:18:31
ni personalizar nada más. 00:18:33
Entonces, yo he llegado a este punto. Repito 00:18:35
un poco el proceso que hemos hecho, pero sin 00:18:37
buscar ayuda prácticamente en ningún sitio, 00:18:39
solo tirando de los métodos que me ofrece, así a lo 00:18:41
loco, que normalmente uno no va a lo loco. 00:18:43
Uno, pues, cuando ya tiene claro 00:18:45
lo que quiere hacer, busca en la ayuda cómo hacerlo. 00:18:47
Pero bueno, primero, hemos 00:18:49
hecho lo más importante, que es 00:18:51
ubicar en nuestra 00:18:53
aplicación dónde queremos 00:18:57
que se abra la ventana, dónde queremos. Pues, 00:18:59
queremos que se abra la ventana cuando lleguemos 00:19:01
a la acción performe. Eso es lo más importante. 00:19:03
Y aquí quiero que se abra. 00:19:05
¿Cómo consigo que se abra una ventana 00:19:07
de exploración de archivos? Pues afortunadamente 00:19:09
hay una clase 00:19:11
que me abre una ventana de exploración de archivos. 00:19:12
Pues venga, estupendo. 00:19:15
Es este objeto, lo instancio. 00:19:17
Y ahora ya miro los métodos que tiene 00:19:19
para ver cómo consigo que se abra esa ventanita. 00:19:21
Pues mira, 00:19:24
con este método consigues que se abra 00:19:25
esa ventanita. Muy bien. 00:19:27
Y ahora esa ventanita que se abre 00:19:28
se cerrará como consecuencia 00:19:30
de que le des tú a guardar o cancelar 00:19:33
entonces una vez que la ventana se ha cerrado 00:19:34
hay dos informaciones 00:19:37
que necesitas, ver a qué 00:19:39
botón has dado y ver qué hay aquí 00:19:41
hay dos informaciones que necesitas una vez 00:19:42
que se ha cerrado, pues lo siguiente 00:19:45
es averiguar y cómo saco yo esa información 00:19:46
cómo la saco, vale 00:19:49
pues la información de qué botoncito se ha pulsado 00:19:51
una vez cerrada 00:19:53
esa información 00:19:54
la sacamos del valor de retorno 00:19:55
de esta ventana 00:20:04
cuando este método se ejecuta, se abre la ventana 00:20:05
y ahí se queda parado el programa 00:20:07
eso es como si fuera un scan 00:20:09
ahí se queda parado 00:20:11
cuando cerremos, este método ya termina 00:20:12
este método termina y me devuelve 00:20:15
el botón que yo puse aquí 00:20:17
y me lo devuelve ahí 00:20:19
bueno, pues ya está 00:20:21
una vez que yo llegué aquí es porque la ventana se cerró 00:20:23
ahora ya digo, vamos a ver 00:20:25
¿qué botón diste? 00:20:27
¿Diste el de cancelar? 00:20:27
No, no diste el de cancelar 00:20:30
Pues si no diste el de cancelar 00:20:32
Vamos a coger el texto 00:20:33
Que esté aquí, que es la otra información 00:20:35
Que necesitamos, esta 00:20:37
Entonces, siguiente pregunta 00:20:39
¿Y de dónde saco yo esta información? 00:20:41
Pues seguimos indagando en el file chooser 00:20:43
¿Puedes enseñar 00:20:45
Todo lo que está aquí? 00:20:47
Sí, entonces 00:20:49
Claro, aquí 00:20:51
Lo más importante es 00:20:55
Que el file chooser tiene el método 00:20:56
que te da lo que tú tienes 00:20:59
lo que hay en esa ruta 00:21:02
pero te lo da en formato file 00:21:04
y para sacar del formato file 00:21:06
la ruta tienes que hacer esto 00:21:08
y ahora ya esa ruta 00:21:09
¿qué hacemos con ella? 00:21:12
lo que nos dé la gana, en mi caso ponerla en el área de texto 00:21:13
pero con esa ruta 00:21:16
podríamos abrir archivo, leerlo 00:21:18
cosas que ahora mismo no sabemos hacer 00:21:19
este file chooser no te hace nada 00:21:21
con los archivos, lo único que te hace 00:21:24
es abrirte una ventana de diálogo 00:21:26
abrirte y permitirte 00:21:27
que tú selecciones un archivo 00:21:29
y cuando la cierras, devolverte el nombre 00:21:30
de ese archivo, nada más, pero el nombre 00:21:33
con el archivo no he hecho nada 00:21:35
si tú quieres luego hacer algo con el nombre de este archivo 00:21:36
ya lo haces tú 00:21:39
entonces 00:21:40
si probamos esto 00:21:43
cogiendo el nombre de un archivo cualquiera 00:21:50
por ejemplo, este archivo 00:21:52
le damos a 00:22:02
esto de aquí y efectivamente 00:22:05
me pone ahí la ruta 00:22:08
que era de lo que se trataba 00:22:09
me pone la ruta del archivo que he seleccionado 00:22:11
lo normal es que con esa ruta 00:22:13
luego ya quisiéramos hacer cosas 00:22:15
pues como coger ese archivo 00:22:17
comprobar cosas de él, lo que fuera 00:22:19
¿vale? 00:22:21
entonces esta es el uso 00:22:24
del file chooser sin prácticamente 00:22:25
personalizar nada, pero se pueden 00:22:27
aquí como he puesto save 00:22:29
pues por eso me ha dado guardar, aquí sería 00:22:31
open mejor 00:22:33
pero luego este objeto se puede personalizar 00:22:34
de manera que solo te permita ver archivos de texto 00:22:37
para seleccionar lo que uno quiera. 00:22:40
Por ejemplo, yo aquí en esta versión 00:22:42
lo que he añadido es, por ejemplo, 00:22:45
el JFC una vez hecho, el File Chooser, 00:22:48
puedes personalizarle cosas. 00:22:51
Yo aquí le he personalizado que te deje seleccionar 00:22:53
tanto archivos como directorios, por ejemplo, 00:22:56
porque puedes hacer que solo te deje seleccionar archivos. 00:22:59
Además, le he puesto un filtro 00:23:02
para que solo te muestre 00:23:04
archivos 00:23:06
con esta extensión 00:23:08
y aquí con esto de aquí, por ejemplo 00:23:09
voy a poner esto mismo en el que acabamos de hacer 00:23:12
en esto 00:23:14
vale, o sea que me deje tanto ficheros 00:23:24
como directorios 00:23:29
le pongo un filtro para que solo me deje coger 00:23:30
de texto y además me diga 00:23:33
me de un aviso y me diga solo texto 00:23:35
lo que yo quiera 00:23:37
le pongo el filtro al file chooser 00:23:38
y ahora ya abro la ventanita, abro esto de aquí 00:23:42
Lo volvemos a ejecutar 00:23:44
Abro 00:23:46
¿Veis? Efectivamente 00:23:47
Solo me deja seleccionar TXT 00:23:50
Yo por mucho, y además me avisa 00:23:52
Oye, cuidado que solamente puedes texto 00:23:54
¿Vale? Esto solamente 00:23:57
Lo pone ahí 00:23:59
Entonces, igual que esto, se pueden personalizar más cosas 00:23:59
Se puede personalizar el texto que va en los botones 00:24:06
Un montón de chorradas 00:24:09
Bueno, pues con esto 00:24:09
Simplemente quería 00:24:12
Que no os volvierais tontos con la paleta 00:24:13
La paleta para que vale 00:24:16
Para colocar de forma sencilla 00:24:17
Componentes que van a estar ahí siempre 00:24:20
En la 00:24:22
En la interfaz, ahí colocados 00:24:24
Esperando cosas, ya está 00:24:26
Pero luego en la interfaz pasarán muchas cosas 00:24:27
Cosas que se abran, que se cierran 00:24:29
Todas esas cosas pasan por código 00:24:31
Y habrá que hacerlas dentro del código 00:24:32
Como respuesta a eventos, etc 00:24:34
Bueno 00:24:37
Eso en cuanto a 00:24:40
Este de aquí 00:24:43
El 7 es una tontería 00:24:44
porque el 7 es 00:24:49
una etiqueta, un botón, me da igual lo que hayáis puesto 00:24:50
que su evento 00:24:53
primero, está asociado 00:24:54
no es el ActionListener, sino que es el 00:24:56
mouse, es un evento de ratón 00:24:59
el mouseEnter, por ejemplo 00:25:01
ese, y ahora 00:25:03
¿cuál será la respuesta al evento? 00:25:05
pues cambiar 00:25:07
la coordenada 00:25:08
x e y de ese elemento 00:25:11
cambiarlo a sitios aleatorios, y ya está 00:25:12
entonces es un MouseListener 00:25:14
donde, dentro del 00:25:16
se hace un setbounce 00:25:19
para cambiarle 00:25:20
las coordenadas x e y 00:25:22
y luego 00:25:25
además se habrán generado aleatoriamente 00:25:27
si coinciden las que se han generado con las aleatorias 00:25:29
ya es terminado 00:25:31
sería algo 00:25:32
como 00:25:34
como 00:25:37
este código de aquí 00:25:39
este código de aquí 00:25:40
a ver, lo voy a abrir con el 00:25:44
con el de diseño 00:25:47
vale, como veis 00:25:49
este solo tiene un botón 00:26:00
ya está, solo tiene el botoncito, no tiene nada más 00:26:02
nada más 00:26:05
vale, pues ¿cuál es el evento de respuesta? 00:26:06
aquí no es un ActionListener, es un 00:26:08
MouseListener, es un MouseListener 00:26:10
de hecho, yo se lo he añadido con el 00:26:13
con el Builder 00:26:14
por eso cuando 00:26:16
le doy aquí al botón derecho 00:26:18
el que tengo añadido es este 00:26:26
tengo añadido este, de todos 00:26:29
los que hay, este 00:26:31
cada vez que el ratón entre en la zona 00:26:33
cada vez que el ratón responde a un evento 00:26:34
ese es el que tengo añadido 00:26:36
vale, pues si nos vamos a él 00:26:38
vale, si nos vamos a él, la aplicación 00:26:40
bueno, pues esto 00:26:49
más o menos lo que 00:26:50
vosotros habéis hecho 00:26:53
a ver 00:26:54
vale, yo es que aquí lo tengo ampliado 00:26:59
para que te cuente cuánto has tardado 00:27:03
en encontrarlo, pero es una chorrada 00:27:05
vale, pues entonces 00:27:07
cuando la aplicación arranca 00:27:09
selecciona una posición aleatoria 00:27:14
¿verdad? o sea, este es el constructor 00:27:17
de mi interfaz 00:27:19
ese es el constructor 00:27:21
el constructor de mi interfaz 00:27:23
no hace nada, nada más que añadir 00:27:25
el botoncito este, lo añade 00:27:27
y además al botoncito este 00:27:29
le añade un mouse listener 00:27:31
con el evento, que vemos ahora 00:27:33
con el evento, hace esto 00:27:35
y luego además ¿qué hace? 00:27:37
genera una posición aleatoria 00:27:39
que es la posición de destino 00:27:41
esta posición aleatoria 00:27:42
pues la genero con un método para que sea más cómodo 00:27:44
genero posición aleatoria 00:27:46
así, simplemente 00:27:48
hago unas coordenadas, coordenada x e y 00:27:50
esta es la coordenada x 00:27:52
una aleatoria 00:27:54
entre esto y 400 y la 00:27:56
ordenada y 00:27:58
entonces 00:27:59
estas dos 00:28:02
400 y 250 yo las he puesto 00:28:04
así porque mi frame 00:28:06
mi frame tiene este tamaño 00:28:08
entonces mi frame como tiene este tamaño 00:28:14
450 de ancho 00:28:17
300 de alto 00:28:19
yo he puesto que la 00:28:20
coordenada sea entre 400 00:28:22
y 250 para asegurarme de que cae siempre dentro 00:28:25
esto sería mucho más genérico 00:28:27
si aquí cogemos el frame 00:28:29
y le sacamos sus coordenadas 00:28:31
con los métodos que tiene un getX y un getY 00:28:33
vale, tiene un getX 00:28:35
y un getY, yo saco 00:28:37
y aquí pongo ese tamaño 00:28:39
del frame, pongo ese tamaño y ya está 00:28:41
Sería mucho más genérico 00:28:43
Bueno, pues entonces 00:28:44
Genero posición aleatoria 00:28:47
Una posición aleatoria que es la posición final que la genero aquí 00:28:48
Y ahora, cada vez que 00:28:50
Entre en el ratón, ¿qué es lo que va a pasar? 00:28:53
Lo que yo ya he hecho aquí en el mouse listener 00:28:55
Que es este 00:28:57
¿Y qué he hecho en el mouse listener? 00:28:57
Pues bueno 00:29:02
A ver 00:29:03
Genero una posición aleatoria 00:29:04
Para el botón 00:29:08
¿Vale? Genero una posición aleatoria 00:29:10
Para el botón 00:29:12
y se la fijo aquí 00:29:13
al botón le voy a poner esa posición aleatoria 00:29:15
que acabo de generar 00:29:18
¿vale? este es un método genérico 00:29:19
que me da una coordenada x e y 00:29:21
pues genero unas coordenadas 00:29:23
x e y y se las fijo al ratón 00:29:26
con su método, ala, colócate ahí ratón 00:29:27
y ahora 00:29:30
me falta por comprobar si el ratón 00:29:31
llegó a la zona 00:29:34
de finalización 00:29:36
entonces la coordenada x 00:29:37
aquí para que no tenga que ser 00:29:39
tal cual, pues lo he cuadrado 00:29:42
para ver si está 00:29:44
sí, pero el tamaño es el mismo que tenía 00:29:45
para que no cambie 00:29:52
del botón he cogido el ancho que tenía, o sea, el mismo 00:29:52
el tamaño del botón no lo cambio 00:29:56
y solamente cambio 00:29:57
la coordenada para que se mueva 00:30:00
pero al setbounce hay que pasar las cuatro cosas 00:30:01
efectivamente, coordenada X, coordenada Y 00:30:03
tamaño horizontal del botón 00:30:06
tamaño vertical 00:30:08
como el tamaño vertical y horizontal no lo cambio 00:30:09
pongo el que ya tenía, que es este 00:30:11
y esto sí que les paso las nuevas 00:30:13
Y ahora, para que esto termine alguna vez 00:30:15
En lugar de decir 00:30:19
Oye, la coordenada que acabas de generar 00:30:20
Esta 00:30:22
Es igualita a la final 00:30:23
Es que eso es mucho atinar 00:30:25
Yo aquí lo he modificado para ver si está en un cuadrado 00:30:27
De lado 50 00:30:30
Si ha caído en un cuadrado de lado 50 00:30:32
Partiendo de la posfinal 00:30:33
Entonces, si la coordenada X 00:30:34
Está comprendida en un cuadrado de 50 00:30:36
Alrededor de la posición final 00:30:39
Que sería esto 00:30:43
si está comprendida 00:30:45
pues entonces ya digo, ya está, ya hemos parado 00:30:46
el botón ya lo hago invisible 00:30:49
y ya 00:30:50
digo, venga, esto es lo que has tardado 00:30:52
cojo la hora actual 00:30:55
y la resto 00:30:57
a la hora inicial que cogí 00:31:00
cuando empezó el juego 00:31:01
la cogí aquí y ya está, pero esto es por añadirle 00:31:02
una chorra, vale 00:31:05
y no tiene más 00:31:06
el programa este 00:31:08
entonces si ejecutamos esto 00:31:11
Pues hasta que no caiga en el 00:31:13
Caerá en el cuadrado en algún momento 00:31:20
Suponemos 00:31:22
Y entonces se inhabilitará 00:31:23
Habría que haberlo puesto de más de 50 00:31:26
De 75 00:31:31
Espera, vamos a por lo de 00:31:33
Vamos a por lo de 100 00:31:35
Para que caiga alguna vez 00:31:38
Porque va a caer 00:31:39
Un puesto tan grande 00:31:41
Que a la primera ya ha entrado dentro 00:31:54
Pues ya está 00:31:56
¿Vale? 00:31:58
bueno, esto era simplemente para capturar otro evento 00:32:00
ya está, para capturar otro evento 00:32:02
y programar un poquito más, nada más 00:32:04
vale, vamos a parar aquí un momento 00:32:06
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
6 de mayo de 2024 - 19:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
156.00 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid