Saltar navegación

20250306 GUI_3 - 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 8 de marzo de 2025 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Recordáis la arquitectura general de una aplicación con interfaz gráfica swing, ¿verdad? 00:00:00
Que era, tenemos que tener un marco, un frame. 00:00:07
Un frame hay que tener, que es el punto de partida, ¿vale? 00:00:12
El frame general lo que hacemos es personalizarlo mediante la herencia, ¿vale? 00:00:18
Lo personalizamos mediante la herencia y ¿cómo lo personalizamos? 00:00:24
pues en el momento en el que se construye 00:00:27
que es en el constructor 00:00:29
en el momento en el que se construye 00:00:31
pues le metemos cosas 00:00:33
vale, pues en el momento en el que se construye 00:00:34
le metemos cosas como por ejemplo 00:00:37
un comportamiento 00:00:39
de que se cierre el proceso cuando le damos 00:00:40
a la X, que eso lo hacíamos con esta línea 00:00:43
le asociamos 00:00:46
unos componentes 00:00:50
que hemos creado 00:00:53
todo esto lo hacemos en el constructor 00:00:54
el construir la interfaz, la construimos en el constructor 00:00:56
que es el momento en el que se instancia el objeto 00:01:00
pues le pegamos unos componentes 00:01:02
los que hemos decidido previamente en toda esa primera parte 00:01:06
enorme de construcción de prototipos 00:01:09
que nos interesan, pero estos componentes 00:01:11
no se pegan nunca al frame, el frame es una especie 00:01:16
de raíz, de marco general 00:01:18
donde ponemos contenedores o paneles 00:01:21
Bueno, hay más tipos de contenedores 00:01:25
No solo los paneles 00:01:27
El panel es el más habitual 00:01:28
Al marco le ponemos contenedores 00:01:30
Siendo el panel el más habitual 00:01:33
Y ya a esos contenedores 00:01:35
Le ponemos los componentes 00:01:36
Bueno, pues 00:01:38
Un frame cualquiera siempre trae 00:01:39
Un panel por defecto 00:01:42
Pegado a él 00:01:45
Cuyo tamaño es el mismo tamaño del frame 00:01:46
Siempre lo trae 00:01:49
Los de atrás, Rodrigo y compañía 00:01:49
Y todos que se callen 00:01:53
Entonces ese panel por defecto lo extraemos con este método 00:01:54
De nuestro frame extraemos ese panel por defecto 00:02:00
Y a ese panel por defecto es el que le ponemos los componentes 00:02:03
En nuestro caso que es nuestra primera interfaz sencilla sin complicarnos la vida 00:02:07
Entonces esos componentes si los ponemos sin más 00:02:10
Ya vimos que se ponen unos encima de otros 00:02:16
Y además con el tamaño agrandado al tamaño del panel 00:02:19
Ese aspecto no nos gusta 00:02:22
pues entonces tenemos que decirle al panel 00:02:23
oye, voy a crear un gestor de ubicación 00:02:28
un gestor de ubicación que te va a ti 00:02:32
a indicar cómo los tienes que colocar 00:02:35
bueno, pues gestores de ubicación hay de muchos tipos 00:02:37
este era el más sencillo 00:02:40
que es un gestor de ubicación en filita 00:02:42
entonces el gestor de ubicación en filita 00:02:45
que es el flow layout 00:02:48
pues le ordena al panel 00:02:49
panel cuando se le asocia, que con el set layout se lo asociábamos, este gestor de ubicación se lo 00:02:52
asociábamos al panel con el set layout, pues desde el momento en el que se le asocia ya le dice todo 00:02:59
lo que llegue a ti en fila, todo lo que llegue a ti en fila, todo. Pues ahora ya texto saluda y despide, 00:03:05
todo en filita. Por eso se llama flow layout. Hay más gestores como el grid layout que es para 00:03:10
colocar en una rejilla, bueno 00:03:16
los actores de ubicación 00:03:18
que le indican al panel 00:03:19
al panel, no al frame 00:03:22
al panel, porque el panel es el que tiene los componentes 00:03:24
cómo se van a colocar 00:03:26
bueno, pues hicimos este pequeño ejemplo 00:03:28
el panel grande 00:03:30
sí, sí, sí, porque estamos usando 00:03:30
solamente el panel grande que viene de serie 00:03:34
para todo ahora mismo 00:03:36
que sería el equivalente al bot 00:03:37
sí, supongo 00:03:39
sí, pero luego en el bot 00:03:42
tú puedes poner diferentes contenedores 00:03:45
pequeñitos, diferentes cosas. 00:03:47
Pues sería el equivalente a ese, sí. 00:03:49
Vale. 00:03:52
Bueno, pues entonces 00:03:53
la interfaz se quedaba 00:03:54
construida, pero teníamos luego 00:03:57
que resolver el problema 00:03:59
ahora ya de la respuesta 00:04:01
a los eventos del usuario. 00:04:03
La respuesta a los eventos. 00:04:05
Entonces la respuesta a los eventos sigue este modelo. 00:04:06
Tiene que existir 00:04:10
un objeto creado 00:04:11
en mi aplicación, tiene que existir un objeto 00:04:12
creado que sea capaz 00:04:15
de darse cuenta de que algo ha pasado a la interfaz. 00:04:17
Eso no es fácil, porque tiene que ser capaz de darse cuenta 00:04:21
de que ha habido un evento en el teclado. 00:04:23
Tiene que ser capaz de darse cuenta. 00:04:26
Bueno, pues los objetos que son capaces de darse cuenta 00:04:28
de que algo ha pasado, asincronamente, de repente, 00:04:30
asincronamente de que algo ha pasado, 00:04:33
son los objetos en general listener, los que se llaman listener. 00:04:35
Y se llaman listener porque son objetos que heredan 00:04:39
de interfaces Listener 00:04:42
o implementa interfaces Listener 00:04:45
que hay muchas interfaces Listener 00:04:47
ya veremos 00:04:49
pero la más general 00:04:49
es la ActionListener 00:04:51
exacto 00:04:54
entonces cada Listener 00:04:56
cada clase Listener está especializada 00:04:58
en un tipo de eventos 00:05:00
¿vale? 00:05:03
la interfaz ActionListener 00:05:04
está especializada 00:05:07
en los eventos por defecto 00:05:09
que se llaman 00:05:10
que es en lo que habitualmente 00:05:11
se hace en cada componente 00:05:13
en un botón que es lo que habitualmente 00:05:15
se hace, hacerle click 00:05:17
pero en un área de texto en la que tú 00:05:18
metes texto, ¿cuál es el evento 00:05:21
por defecto? darle al enter 00:05:23
tú metes texto, das al enter 00:05:25
pues el ActionListener escucharía el enter 00:05:27
de un área de texto, o sea el ActionListener 00:05:29
no es que sea siempre click 00:05:31
el ActionListener es el capaz de escuchar 00:05:32
el evento más habitual 00:05:35
o el evento por defecto 00:05:37
de cada componente, que cada uno tiene 00:05:39
el suyo. Y hay algunos que no tienen. 00:05:41
No tienen evento por defecto. Con lo cual, la acción 00:05:43
listener nunca sería capaz de escuchar nada 00:05:45
sobre ellos. Hay componentes que no tienen evento por defecto. 00:05:47
Vale. 00:05:50
Bueno, pues, entonces, si yo 00:05:51
quiero crear un objeto que sea 00:05:53
capaz de escuchar 00:05:55
el evento por defecto del componente 00:05:56
que sea, sí, 00:05:59
pero así un poquito más humildemente. 00:06:04
Pasa, pasa. 00:06:07
Y con más celeridad. 00:06:14
Bueno. 00:06:22
tenemos, si queremos 00:06:22
que la interfaz sea capaz 00:06:25
de espabilar cuando activamos 00:06:26
el evento por defecto del componente 00:06:29
Buenas, ¿qué tienes que decirnos? 00:06:30
¿Puedo pasar, por favor? 00:06:40
Eso desde la puerta 00:06:42
Llamas primero 00:06:43
Es que hay que enseñárselo todo a estos fríos 00:06:49
Sí 00:06:51
¿qué ha ocurrido? porque llegas tarde 00:06:52
no te he dicho que puedas pasar todavía 00:06:55
¿qué ha ocurrido? porque llegas tarde 00:06:57
en fin, seguimos 00:07:00
para tener un objeto ahí 00:07:03
que sea capaz de despertarse y espabilar 00:07:08
cuando ocurre el evento 00:07:10
por defecto del componente que sea 00:07:12
lo que tenemos que hacer es 00:07:14
crear una clase que implemente 00:07:15
de ese listener 00:07:18
que es el tipo de listener que es capaz 00:07:19
de escuchar los eventos por defecto, 00:07:22
creamos una clase y luego ya instanciamos un objeto 00:07:24
de esa clase. ¿Por qué no 00:07:26
instanciamos directamente una acción listener? 00:07:28
Por dos cosas. 00:07:31
Una, porque es una interfaz. 00:07:32
No se instancian las interfaces, ya lo sabemos. 00:07:34
Y otra, porque el objeto 00:07:36
que instanciamos, ese que tiene que ser capaz de 00:07:38
escuchar, tiene que estar personalizado 00:07:40
para tener 00:07:42
dentro el código concreto 00:07:44
con el que queremos que responda 00:07:46
cuando ese evento ha ocurrido. Entonces, tiene que ser 00:07:48
un objeto personalizado con el 00:07:50
código concreto que queremos 00:07:52
que ocurra cuando se dé ese evento 00:07:53
vale, pues entonces 00:07:56
hacemos la clase que implemente 00:07:57
ActionListener para darle la capacidad 00:08:00
de escuchar eventos 00:08:02
por defecto de los componentes 00:08:04
y ahora ya 00:08:05
personalizamos este método 00:08:07
que en ActionListener está vacío, lo personalizamos 00:08:09
dándole el código 00:08:12
que queremos que 00:08:13
se ejecute cuando pase 00:08:15
ese evento por defecto 00:08:18
en este caso le pusimos simplemente que muestre 00:08:19
por consola una cosa 00:08:22
vale, bueno pues 00:08:23
entonces, ahora esta clase está hecha 00:08:31
ahora ya podemos instanciar un objeto de esta clase 00:08:33
entonces este objeto se instancia 00:08:35
muy bien, se instancia 00:08:37
y está aquí instanciado 00:08:39
práctica habitual, se crea un objeto 00:08:40
para cada elemento que lo va a llamar 00:08:45
ahora nos vamos a meter en eso 00:08:46
porque vamos a empezar a resolver el problema de 00:08:49
cómo pasar los parámetros, ahora lo vamos a ir 00:08:51
resolviendo, vale 00:08:53
entonces 00:08:55
aunque la respuesta 00:08:56
última y más real sería depende 00:08:59
como siempre, pero en cualquier caso vamos a 00:09:01
volver ahora a eso 00:09:03
es que de verdad, la vida son 00:09:04
muchos dependes, así que 00:09:07
mentalizados, entonces 00:09:09
lo importante 00:09:11
uno no tiene que tener 00:09:13
conocimientos, uno tiene que tener 00:09:15
desarrollar capacidad de tomar decisiones 00:09:17
tiene que tener recursos para tomar 00:09:19
decisiones correctas 00:09:21
de ahí la importancia 00:09:23
de asumir que todo depende, claro 00:09:25
bueno, pues entonces, nosotros ya hemos 00:09:27
instanciado este objeto 00:09:29
este objeto ya es capaz 00:09:30
de escuchar eventos por defecto, porque es una acción 00:09:32
listener, y además tiene un 00:09:35
código dentro con el que podría responder 00:09:37
magnífico 00:09:39
y ahora nos pregunta, si ya, yo soy capaz de escuchar 00:09:40
eventos por defecto, ¿de quién? 00:09:43
de este área de texto, del panel 00:09:45
del scroll bar que me habías 00:09:47
puesto, ¿de quién escucho yo? no puedo escucharlos 00:09:49
a todos, tengo que escuchar a uno 00:09:51
¿a quién? vale, pues 00:09:53
ahora es cuando, al componente 00:09:55
que diga, no, no, escucha ese 00:09:57
pues se lo añadimos 00:09:59
con el método de AddAttionListener, le decimos 00:10:00
tu objeto escucha saludar 00:10:02
escucha, estate pendiente 00:10:04
estate enganchado a este componente 00:10:06
estate enganchado a este 00:10:09
y cuando salte el evento por defecto 00:10:10
cuando detectes que se ha hecho 00:10:13
el evento por defecto en ese componente 00:10:15
y ahora ya te despiertas y ejecutas tu código 00:10:16
¿vale? 00:10:18
pero instanciar el objeto simplemente 00:10:20
no hacemos nada, le tenemos ahí instancia de memoria 00:10:22
pero no está enganchado a ningún componente, ¿vale? 00:10:25
Le podemos enganchar a más de uno, 00:10:28
no tiene por qué estar escuchando solo a uno, 00:10:30
como fue el ejemplo del otro día. 00:10:31
Le pusimos a la escucha de dos, 00:10:33
tanto del botón de saludar como el de despedir. 00:10:35
Con lo cual, cualquiera de los dos que recibiera el evento por defecto, 00:10:38
este objeto iba a saltar e iba a despertarse, ¿vale? 00:10:42
Iba a saltar e iba a despertarse, con lo cual iba a llegar aquí. 00:10:45
Despertarse significa, pum, entrar en esta zona, ¿vale? 00:10:48
Entonces, aquí efectivamente, como este objeto podía haber despertado por dos fuentes distintas, pues si queríamos que respondiera de forma distinta a las dos fuentes, teníamos que distinguir dentro de alguna manera. 00:10:53
Entonces, ¿cómo podemos distinguir dentro quién fue el que recibió el evento? ¿Quién es el que te ha despertado de los dos botones? ¿Quién te ha despertado? Pues el que me ha despertado está aquí metido. 00:11:06
porque cuando este objeto se despierta 00:11:16
la máquina virtual le pasa un objetito 00:11:19
a Action Event con toda 00:11:22
la información del componente 00:11:24
que recibió el evento 00:11:25
de la hora en la que se produjo 00:11:27
un montón de cosas relacionadas 00:11:29
con ese evento 00:11:32
de ese montón de cosas que podemos sacar 00:11:32
información relacionada con el evento 00:11:35
una de las que podemos sacar 00:11:38
es que objeto 00:11:39
fue, si es que queremos 00:11:41
sacarlo porque este evento está asociado 00:11:43
a muchos. Si está asociado a muchos, pues vamos a 00:11:45
tratar de sacarlo. Bueno, pues con este 00:11:47
método sacábamos el object. 00:11:49
El objeto object que 00:11:51
nos dio el evento. 00:11:53
En nuestro caso, como sabíamos que 00:11:55
cualquiera de los dos iban a ser botones, 00:11:57
pues hacíamos el casting 00:12:00
directamente. Entonces, 00:12:01
este es el botón 00:12:03
que causó el evento. 00:12:05
Y ya lo usábamos de esta manera. 00:12:07
Si el botón que causó el evento, 00:12:09
el texto que tiene puesto encima 00:12:11
es saludar, pues hace esto. 00:12:13
Si el botón que causó el evento 00:12:14
Que es este, el texto que tiene puesto encima 00:12:17
No es saludar 00:12:19
Pues entonces haces otro 00:12:20
¿Vale? Y ahí nos quedamos 00:12:22
Dime 00:12:24
El ruidito 00:12:25
No hay más derecho 00:12:31
No lo sé 00:12:36
Igual es porque has llegado tarde 00:12:42
Y no te ha dado tiempo a 00:12:44
Claro, no te ha dado tiempo a corregirlo 00:12:46
en el rato este, por haber llegado tarde 00:12:50
es normal, pasa a menudo 00:12:52
bueno, entonces ya tenemos nuestro 00:12:53
frame personalizado, nuestra aplicación es un main 00:12:56
nuestra aplicación es un main 00:12:58
pues ya está, nuestra aplicación lo único que hace es 00:12:59
instanciar el frame 00:13:02
al instanciar el frame 00:13:03
llama al constructor, lógicamente, el constructor 00:13:05
construye la interfaz, hace todo lo que hemos visto 00:13:08
bla bla bla, todo en el constructor 00:13:10
porque es en el momento en el que se crea 00:13:11
y luego además este frame 00:13:14
que ya está hecho, podemos hacer 00:13:16
cosas con él, como darle un tamaño 00:13:18
hacerle visible, no hacerle visible 00:13:20
y algunas cosas que podríamos hacer en general con el tema 00:13:21
pues estar en la arquitectura 00:13:24
básica, construir 00:13:26
la interfaz mediante 00:13:28
un frame personalizado 00:13:29
y luego crear tantos listeners 00:13:31
como necesitemos 00:13:34
y asociarlos a los componentes 00:13:35
a los que tienen que estar ahí escuchando 00:13:38
y ya está, y luego instancia el frame y se acabó 00:13:40
esto muy en general 00:13:44
estás deseando preguntar pero estás diciendo 00:13:45
bueno voy a esperar un rato 00:13:49
¿No es eso lo que te está ocurriendo? 00:13:51
A ver 00:13:53
Vale 00:13:53
Bueno, pregunta 00:13:55
Hay tres veces que te diga depende, que te diga espera 00:13:58
O que te responda, pregunta 00:14:01
¿El ser visible 00:14:02
No sería mejor meterlo en el constructor 00:14:04
De base que sea tú? 00:14:06
Depende, ya 00:14:09
Sí, no, a ver, efectivamente 00:14:10
Esto ya sí que es una cuestión de gustos 00:14:13
Pero como por ver la generalidad 00:14:15
Claro, en este caso 00:14:16
Pues tú lo puedes poner aquí 00:14:17
Y listo 00:14:21
Vale 00:14:23
Estamos en el método 00:14:24
Set visible 00:14:28
Ah, claro, ya decía yo por qué me lo pones rojo 00:14:32
Vale, lo podemos poner ahí 00:14:34
No hace falta que pongamos el dis 00:14:36
Ya lo sabéis, estamos en el propio frame 00:14:38
Sí, pero por qué llegas tarde 00:14:43
Bueno, adelante 00:14:45
Pero no entréis así alegremente 00:14:49
Que lo he dicho ya tres veces 00:14:51
Tenéis que llamar, preguntar si se puede 00:14:52
En realidad todos están sufriendo por culpa de Ángel 00:14:54
Que es el que ha entrado aquí como 00:15:01
Vale, pues aquí el disk 00:15:02
No hace falta ponerlo, como bien sabéis 00:15:08
Porque se refiere al propio frame 00:15:10
¿Vale? Si lo ponemos aquí 00:15:12
Pues aquí obviamente nos sobraría, lógicamente 00:15:14
Y el size también 00:15:17
El size también lo podríamos fijar aquí dentro 00:15:18
Y aquí de hecho 00:15:21
Podríamos ajustarlo 00:15:22
Porque tenemos la información de todos los 00:15:24
componentes que hay 00:15:27
¿podrías sacar el tamaño de la pantalla 00:15:28
de la que estás llamando? 00:15:31
¿de alguna manera? ¿podrías llamar algún tipo de método? 00:15:33
sí, seguramente haya un 00:15:35
getSize o algo así 00:15:37
si es que esto tiene 00:15:38
hay un getSize que te da el objeto de dimensiones 00:15:39
con el tamaño que tiene el frame 00:15:43
el panel también tendrá un getSize 00:15:45
o sea, puedes jugar un montón con 00:15:47
¿vale? 00:15:48
entonces aquí podríamos hacer también el setSize 00:15:51
¿y para el monitor? 00:15:54
para que se saque el tamaño del monitor? 00:15:56
No lo sé. 00:15:58
Pregúntese a la HGPT. 00:15:59
Seguro que sí. 00:16:00
Seguro. 00:16:01
A ver, hay millones de métodos, 00:16:02
millones de clases, 00:16:03
millones de todos. 00:16:04
Ya te digo que hay libros 00:16:05
de miles de páginas 00:16:07
solo de estas cosas. 00:16:08
Si hay métodos de sacar ahora 00:16:09
del sistema, 00:16:10
hay métodos de sacar. 00:16:10
Claro, 00:16:11
habrá métodos para todo, 00:16:12
supongo. 00:16:13
Vale, pues, 00:16:16
por ejemplo, 00:16:18
lo podemos poner aquí 00:16:18
y ya está. 00:16:19
Y si lo ponemos aquí, 00:16:21
pues ya no lo pondríamos aquí. 00:16:23
Bueno, detalles. 00:16:24
Vale, pero ahora 00:16:26
Vámonos a programar 00:16:27
Ahora que es lo que nos interesa 00:16:31
Porque todo esto de Swing 00:16:32
Sobre todo es interesante 00:16:33
Porque nos sigue ayudando 00:16:36
A aprender a programar 00:16:38
Esa es la parte más interesante 00:16:39
¿Vale? 00:16:41
Porque en sí con Swing es difícil que trabajéis 00:16:43
Con JavaFX puede que sí 00:16:45
Y creo que os lo vamos a contar 00:16:47
¿Vale? Un poquito 00:16:49
Vale, pues a ver 00:16:51
Entonces 00:16:56
Está todo claro en lo que estamos 00:16:57
¿Verdad? ¿Qué sueño tenemos? 00:17:00
Si hubieras acostado antes 00:17:03
En vez de estar jugando hasta las tantas 00:17:03
Tendrías menos sueño 00:17:05
¿Eh? 00:17:13
¿Cómo? 00:17:16
Ay, no te he entendido nada 00:17:18
¿Por qué se lo dices así de la nada? 00:17:20
Porque se está durmiendo 00:17:23
¿Qué explicación puede tener eso? 00:17:24
Porque no es porque yo soy muy aburrida 00:17:27
¿Verdad que no? 00:17:28
Bueno, pues entonces la otra explicación es que está 00:17:30
Que ha estado toda la noche jugando 00:17:32
Claro 00:17:34
Oye, tú haz el favor 00:17:36
Bueno 00:17:38
Vale, pues entonces ya estamos todos situados 00:17:40
Ahora, pregunta 00:17:43
No, más que pregunta 00:17:45
Problema 00:17:46
esta interfaz no tiene ningún sentido, 00:17:48
que queramos una interfaz para que nos salude 00:17:50
y que el saludito lo saque por la consola, 00:17:51
porque la consola no va a estar disponible, 00:17:54
no lo vamos a ver. 00:17:57
De hecho, nosotros habíamos hecho aquí una etiqueta, 00:17:58
un label, para poner el texto 00:18:02
y que aparezca en la interfaz. 00:18:04
Entonces, lo que queremos aquí es, 00:18:06
en lugar de esto, esto no lo queremos, 00:18:09
queremos poder acceder desde aquí, 00:18:12
queremos poder acceder desde aquí 00:18:14
al JLabel 00:18:18
que está aquí dentro 00:18:19
de este método local 00:18:21
movida, pero es lo que necesitamos 00:18:22
es lo que queremos 00:18:25
ahora como programadores 00:18:26
que ahora ya si sabéis, el programador no es solo el que sabe 00:18:31
hacer if y while 00:18:33
eso hace falta, si no es el que tiene 00:18:34
una visión 00:18:37
del mundo de los objetos 00:18:39
a ver, que se os ocurre 00:18:40
para poder acceder desde aquí 00:18:43
¿qué cambio? ¿qué podemos hacer? 00:18:48
porque nuestro problema es que 00:18:49
lo acabo de decir, que no queremos mostrar por consola 00:18:50
es absurdo, queremos mostrar la interfaz gráfica 00:18:53
el saludo, para eso habíamos hecho este label 00:18:55
entonces yo quiero 00:18:57
desde aquí acceder a ese label 00:18:59
quiero desde aquí acceder 00:19:01
y ponerle ahí el texto 00:19:03
pero 00:19:04
si ya 00:19:12
El problema es cómo accedo a la etiqueta 00:19:14
No el método 00:19:18
Mi etiqueta es una variable local de aquí 00:19:18
De este método construye interfaz 00:19:21
Es una variable local de aquí 00:19:23
¿Cómo la toqueteo desde aquí? 00:19:24
¿Qué tipo de etiqueta es eso? 00:19:27
¿Se te llama ese tipo de etiqueta? 00:19:34
Es que no te ha llamado ese tipo de etiqueta 00:19:35
Te ha llamado un botón 00:19:37
Claro, te ha llamado un botón 00:19:37
Tú aquí en el GetSource no puedes sacar la etiqueta 00:19:39
En ningún sitio 00:19:42
¿Qué podéis cambiar? 00:19:43
¿Cómo sales de aquí? 00:19:48
¿Cómo accedes desde aquí? ¿Qué puedes cambiar? 00:20:00
¿Qué puedes cambiar en general, en conjunto? 00:20:02
¿Qué podemos añadir? ¿Qué podemos hacer? 00:20:04
Claro, lo ideal 00:20:06
sería, si yo pudiera 00:20:07
pasarle aquí la etiqueta 00:20:10
Si yo le pudiera 00:20:11
pasar aquí la etiqueta 00:20:14
Qué suerte, ¿no? 00:20:15
Si le paso la etiqueta, sí 00:20:18
Pero obviamente no puedo tocar este método 00:20:20
Este método es el método que estoy 00:20:22
Silvia, cállate 00:20:25
Y los de atrás igual 00:20:25
Pero obviamente este método no le puedo tocar 00:20:28
Porque este método está sobrescribiendo 00:20:31
El de acción listener 00:20:33
Este método no le puedo tocar 00:20:34
Con lo cual no puedo usarlo para pasar por parámetro 00:20:37
Nada 00:20:39
Y sin embargo, desde aquí tengo que acceder al 00:20:40
JLabel del otro sitio 00:20:43
¿Un estés? ¿Dónde? 00:20:44
Yo crearía otro método que te saque 00:20:50
A ver 00:20:53
Podría hacer un estés, sacar el JLabel 00:20:56
haciendo un estés no gano nada 00:21:02
mientras esta sigue siendo variable local 00:21:03
de construyente, no gano nada 00:21:05
En todo caso, si la saco fuera 00:21:07
la pongo como protected 00:21:09
pero es que tampoco estaría accediendo 00:21:11
a la label de la de arriba 00:21:13
del objeto de arriba 00:21:15
el extend significa que tú tienes 00:21:16
tus propias propiedades 00:21:19
esas, que sí, que tienen el mismo nombre 00:21:21
que no tienes que escribir código 00:21:24
pero no significa que sean las propiedades del objeto 00:21:25
de arriba del que heredas, no, el objeto 00:21:27
de arriba es uno, el de abajo es otro, que aún no 00:21:29
son sus propiedades 00:21:31
otra cosa que se os ocurre, sacar la etiqueta 00:21:32
y ponerla estática como aquí arriba 00:21:40
ponerla estática 00:21:42
y acceder como variable estática 00:21:44
de esta, mi ventana 00:21:45
a ver, como poder se puede 00:21:47
eso lo podríamos hacer 00:21:49
como solución de programación 00:21:51
pues hombre, a ver 00:21:57
eso es una cosa que podríamos 00:21:58
hacer, esto 00:22:01
lo sacamos aquí 00:22:02
lo ponemos como 00:22:05
estática, vale 00:22:07
pero, ahora que pasa 00:22:11
que sois muy listos vosotros 00:22:13
si lo ponemos como estático 00:22:15
que ya no podemos 00:22:17
acceder a ella 00:22:19
desde el constructor y desde el método 00:22:21
porque si es estática 00:22:24
solo podemos acceder desde métodos estáticos 00:22:25
con lo cual la hemos cagado 00:22:27
¿vale? si es estática 00:22:29
solo podemos acceder desde métodos estáticos 00:22:32
luego no puedo acceder 00:22:34
desde el constructor que es imposible 00:22:36
no le puedo hacer estático al constructor por razones obvias 00:22:37
¿puedo construir algo que 00:22:39
no ha funcionado bien 00:22:42
para que se vea en nave 00:22:44
dártelo en la función 00:22:45
de construir interfaz 00:22:48
y se ve 00:22:49
armazenando una variable 00:22:50
y luego pasarle esta variable 00:22:52
a escuchasaludar 00:22:54
pasárselo 00:22:55
vale, puedes hacerte un get 00:23:00
o sacarla fuera, muy bien 00:23:03
y el siguiente paso que me has dicho, ¿cuál es? 00:23:04
una vez lo tienes fuera 00:23:07
pasárselo a escuchasaludar 00:23:09
¿pero cómo? ¿por dónde? 00:23:10
y luego que haces 00:23:11
o sea por ejemplo 00:23:24
te haces aquí un método 00:23:25
¿no? 00:23:26
vale 00:23:28
este método 00:23:29
por ejemplo 00:23:30
¿cómo le quieres llamar? 00:23:30
no igual que el de arriba 00:23:33
no puede ser 00:23:35
claro para que si le pasas 00:23:37
el parámetro de etiqueta 00:23:38
también 00:23:39
no pero es que este 00:23:40
no no no no 00:23:42
sobre escribirlo 00:23:42
no o sea 00:23:43
yo tengo que hacer otro método distinto 00:23:44
entonces, ¿para qué lo voy a llamar igual que el de arriba? 00:23:46
es que si le paso aquí otro parámetro 00:23:48
ya es un método distinto 00:23:50
no tiene sentido, vale 00:23:51
en cualquier caso no vais mal 00:23:53
pero yo creo que no 00:23:55
vale, me estáis diciendo 00:23:57
le ponemos aquí un método, pero con la idea de llamarlo 00:23:59
desde aquí, porque 00:24:02
de lo que no podemos escaparnos 00:24:03
es que cuando el evento 00:24:06
salte, al método que se va 00:24:08
a llamar es a este, es el de partida 00:24:10
De ahí no podemos sacar 00:24:12
Entonces este método podría llamar a otro 00:24:13
Que si es al que se le ha pasado 00:24:16
La esa, ¿no? 00:24:18
Ya, vale, pero ¿y cómo se le ha pasado 00:24:21
A ese otro método 00:24:22
Esa propiedad? ¿Cómo se le ha pasado? 00:24:24
Estamos en las mismas 00:24:25
¿Cómo le llega a este método? 00:24:26
El método que sea 00:24:30
No, no 00:24:32
No, no, no, no 00:24:34
Efectivamente 00:24:35
Tú quieres esto, ¿no? 00:24:38
J, label, texto 00:24:39
un método y aquí ya trabajar 00:24:41
con la JLabel haciendo lo que fuera 00:24:44
haciendo lo que fuera, pues por ejemplo 00:24:46
texto.sectest 00:24:50
hola 00:24:54
por ejemplo 00:24:55
lo que fuera que quisiéramos hacer 00:24:57
y tú quieres 00:25:00
llamar a recibe 00:25:02
desde aquí, por ejemplo, ya, claro 00:25:04
pero este texto que le tienes que pasar 00:25:06
¿cómo se lo pasas? estamos en las mismas 00:25:08
Podríamos pasarle el objeto entero, ¿no? 00:25:10
Le puede pasar el... 00:25:11
¿Pero desde dónde? 00:25:12
Ese objeto tiene que ser el otro. 00:25:14
Desde el main, ¿no? 00:25:16
¿Desde el main cómo? 00:25:18
Pasarle el objeto entero. 00:25:20
¿Pasárselo dónde y en qué momento? 00:25:21
Porque aquí no estamos llamando a ningún método. 00:25:24
Aquí lo único que estamos haciendo es instanciarlo. 00:25:26
Sí, pues claro, ahí habría que añadirlo. 00:25:30
El texto de lo que pone en el propio botón 00:25:36
sí se puede pasar con el método. 00:25:40
O sea, por ejemplo, lo que estáis diciendo es, escucha, saludar y aquí ¿qué quieres hacer? 00:25:41
Pues aquí no vas a llamar al método porque tú aquí no quieres que salte el evento en este momento. 00:25:55
El evento no salta por programa. 00:25:59
El evento salta asíncronamente cuando le das al botón. 00:26:01
Pero a ver, en realidad vais bien. 00:26:05
Está casi, casi. 00:26:07
el asunto es 00:26:09
desde aquí 00:26:11
a lo que sí que estamos llamando 00:26:13
es al constructor 00:26:15
al constructor sí 00:26:16
pues pasémosle al constructor 00:26:18
hagamos un constructor 00:26:21
que admita parámetros 00:26:22
yo puedo hacer aquí con todos los constructores 00:26:25
que me den la gana, si yo quiero 00:26:27
hagamos un constructor 00:26:29
que reciba los componentes que yo quiero 00:26:30
y que esos componentes inicialicen 00:26:33
propiedades de escucha saludar 00:26:35
Y desde el momento en que están aquí esas propiedades, 00:26:36
ahora este ya accede a ellas sin problema. 00:26:39
¿Vale? 00:26:43
Es decir, lo que me estabais diciendo de 00:26:44
ahora llamo a un método para 00:26:46
inicializar, sí, tendría sentido 00:26:48
si ese método es para 00:26:50
inicializar propiedades que están aquí fuera. 00:26:52
Pero no para 00:26:55
lanzar ya el evento. El evento no se 00:26:56
lanza llamando a ningún, por 00:26:58
código. Es decir, la idea 00:27:00
sería, ¿qué 00:27:02
problema tenía yo aquí? Que yo 00:27:04
aquí necesito, en lugar de hacer 00:27:06
Necesito acceder a esta etiqueta 00:27:08
Y ponerle esto 00:27:11
Sextest hola 00:27:12
Y aquí necesito 00:27:15
Poner esto 00:27:17
Sextest 00:27:19
Adiós 00:27:23
Claro, entonces mi problema es 00:27:29
Ya, y texto 00:27:32
¿Cómo coge valor texto? 00:27:33
¿Cómo coge valor? 00:27:35
Vamos a hacer una cosa 00:27:36
Para que texto sea accesible desde aquí 00:27:37
Sin ningún problema 00:27:40
vamos a hacer que sea una variable de clase 00:27:41
pues que sea una variable de clase, ¿por qué no? 00:27:43
si esto es una clase, le pongo todas las variables que yo quiera 00:27:45
no es una interfaz 00:27:47
pues venga, esto que sea una variable de clase 00:27:48
y ahora 00:27:51
a mí me interesa que esta variable 00:27:56
texto se cargue 00:27:58
se cargue con la etiqueta 00:28:00
del main en el momento 00:28:02
en el cual creo 00:28:04
el objeto 00:28:06
¿vale? bueno pues entonces 00:28:07
estupendamente me hago un constructor 00:28:10
o sería más fácil con el constructor 00:28:12
pero ya que estabais apuntando con este método 00:28:16
pues podríais, a lo mejor así lo veis más claro 00:28:18
porque estabais en esta línea 00:28:21
pues hacéis esto 00:28:22
dis.texto 00:28:24
igual a 00:28:27
texto 00:28:28
es decir, este método 00:28:30
sería solo 00:28:32
sería solo para inicializar 00:28:36
esta variable texto 00:28:40
de clase, inicializarla con la label 00:28:42
que yo le dé, con la que a mí me dé la gana. 00:28:44
¿Vale? Sería solo para eso. 00:28:47
Y aquí 00:28:50
me falta el punto y coma. 00:28:50
Sería solo para eso, ya está, no para saltar el evento. 00:28:52
Entonces, llamando a este método, 00:28:55
yo inicializo esta variable de clase, 00:28:56
esta variable, con la JLabel 00:28:59
que a mí me dé la gana, llamando a este método. 00:29:00
Y ya está, y se queda inicializada. 00:29:02
Y ahora ya, cada vez que salte la acción 00:29:04
perform, cada vez que salte, 00:29:06
¿a quién va a estar accediendo? 00:29:08
A esta. 00:29:10
y esta ya se inicializó 00:29:10
en su momento con la que me interesa 00:29:13
entonces que tendríamos que hacer 00:29:16
aquí en mi ventana 00:29:18
pues después de haber instanciado 00:29:20
el objeto, después de haberlo instanciado 00:29:22
decirle oye tú, objeto 00:29:24
recibe a esta 00:29:25
recibe a esta de aquí 00:29:27
recibe a esa 00:29:29
¿vale? entonces 00:29:33
creamos este objeto 00:29:35
inicializamos su variable 00:29:37
una variable suya 00:29:40
con esta JLabel 00:29:41
digamos que le terminamos 00:29:43
de personalizar 00:29:46
y ya está 00:29:47
y el objeto se queda ahí 00:29:49
y luego lo asociamos aquí 00:29:50
¿vale? 00:29:51
entonces 00:29:53
habremos instanciado el objeto 00:29:54
al hacer el recibe texto 00:29:55
pues 00:29:58
le habremos pasado 00:29:59
la label que nos interesa 00:30:01
del frame 00:30:02
se la habremos pasado 00:30:02
y la habrá usado 00:30:03
para inicializar 00:30:05
su variable local 00:30:06
y ya está 00:30:07
y ahora el método 00:30:08
de acción perform 00:30:09
le accede ahí tranquilamente 00:30:10
entonces nuestro problema de partida era 00:30:11
que este action performance tenía que acceder 00:30:14
a una variable 00:30:17
que no podía recibir por parámetro 00:30:18
ese era el problema de partida 00:30:21
luego, si no la puedes recibir por parámetro 00:30:22
no hay tutía 00:30:25
hay que ponerla como variable de clase 00:30:26
no hay tutía, o la recibes por parámetro 00:30:28
o es una variable de clase 00:30:30
vale, desde el momento en que hemos decidido 00:30:31
que es una variable de clase porque por parámetro 00:30:34
no puedes recibirla, tienes que decir 00:30:36
y ahora esa variable de clase 00:30:38
cómo le doy yo el valor 00:30:40
que me interesa, que es el label del frame 00:30:42
cómo se lo doy yo 00:30:44
bueno, pues venga, me hago un método 00:30:45
en el cual 00:30:47
es como un set 00:30:49
en el cual 00:30:50
de hecho, igual hasta se ve 00:30:54
más claro, si la llamamos 00:30:56
como un set 00:30:58
me hago un set 00:30:59
de esta variable 00:31:03
y ahora ya mi action 00:31:04
performance tranquilamente va a acceder a ese 00:31:08
me hago un set de esta variable y ya está 00:31:10
y ahora en mi frame 00:31:12
construyo 00:31:15
el objeto listener 00:31:17
y le digo, oye tú 00:31:18
tu propiedad 00:31:20
texto, la JLabel 00:31:24
que sea esta 00:31:26
genial, pues ya está 00:31:27
entonces ahora ya este escuchador 00:31:29
está asociado 00:31:36
a estos botones 00:31:38
y cuando este escuchador salte 00:31:39
la etiqueta con la que está trabajando 00:31:41
es esta, porque es la que le hemos pasado a parámetro 00:31:44
es esa 00:31:46
y así podríamos 00:31:46
y así podríamos 00:31:52
hacer que esta interfaz trabajara con muchas 00:31:54
más cosas, si yo quiero que no solo trabaje con la etiqueta 00:31:56
sino que trabaje con un montón de 00:31:59
cosas de la interfaz, además de la etiqueta 00:32:00
pues me cambie el texto de los 00:32:02
botones, por ejemplo 00:32:04
que me los intercambie 00:32:06
por ejemplo 00:32:13
pues entonces si yo, si queremos 00:32:14
que cuando salte el evento, además 00:32:22
de saludar nos intercambie 00:32:24
el texto entre los botones 00:32:26
pues necesita acceder también a esas dos 00:32:27
propiedades, necesita acceder también a ellas 00:32:30
pues en la acción performe entonces 00:32:31
va a necesitar tener estas tres propiedades de clase 00:32:34
pues vamos a hacerle los 00:32:36
tres set 00:32:38
hago solamente el 00:32:38
donde 00:32:48
donde está aquí para que se lo sea, ah aquí 00:32:51
vale, quiero solamente 00:32:54
el set 00:32:56
ah, vale, vale, vale 00:33:01
select setters, vale 00:33:03
en el texto ya lo tengo 00:33:06
así que eso es una tontería, por eso me lo ha quitado 00:33:09
vale 00:33:11
vale, pues ya tengo 00:33:11
los tres sets 00:33:14
entonces lo que me 00:33:15
falta ahora en mi main es después de haber 00:33:19
creado el objeto, pues 00:33:21
pasarle 00:33:22
escucha 00:33:23
saludar.setDespide 00:33:26
con el botón de despide 00:33:30
y escucha saludar.setSaluda 00:33:31
con el botón de saluda. 00:33:40
Vale, entonces mi ActionListener ya puede trabajar con estas tres cosas tranquilamente 00:33:42
porque se las he pasado. 00:33:46
Entonces al haberse las pasado en el set 00:33:49
pues ya las tiene aquí dentro y ya la acción 00:33:51
Performed hace con ellas lo que quiera. Por ejemplo, hemos dicho 00:33:54
que cambiar el texto de los botones 00:33:58
entonces 00:34:00
si estábamos en el if aparte de poner hola 00:34:01
pues entonces 00:34:04
al botón de saluda 00:34:06
tendríamos que intercambiarlos 00:34:08
entonces 00:34:12
saluda 00:34:13
ya no sabemos lo que tendrá 00:34:16
pues entonces aquí podremos hacer 00:34:17
si saluda.gettext 00:34:19
.equals 00:34:23
Saludar y despedir 00:34:26
Eran las dos 00:34:29
Claro 00:34:29
Es saludar 00:34:31
Pues entonces te vamos a poner a ti 00:34:34
Saluda.getTest 00:34:36
No, perdón, setTest 00:34:40
Despedir 00:34:44
Y lo mismo 00:34:53
Y si no es saludar 00:35:01
Entonces saluda.setTest 00:35:02
si no es saludar es que la despedir 00:35:06
entonces le ponemos saludar 00:35:13
bueno y esto lo sacamos 00:35:15
del if de arriba porque se va a hacer en ambos casos 00:35:18
entonces esto lo podemos 00:35:20
sacar de aquí 00:35:21
una vez que hemos hecho lo del saludito 00:35:23
pues ya hacemos el intercambio 00:35:25
entonces y esto lo tendremos que hacer con el otro botón 00:35:27
seguro que lo podemos 00:35:32
hacer con mejor código y menos if 00:35:33
y menos todo pero 00:35:35
y si el texto 00:35:36
de despide 00:35:39
Es saludar, entonces a despide 00:35:40
Ponle 00:35:44
De hecho es que es una tontería hacerlo con otro if 00:35:45
Porque, claro 00:35:51
No, no, no, o sea, tengo que cambiar el otro 00:35:53
Entonces, si saluda tiene saludar 00:35:55
El otro tiene despedir, con lo cual 00:35:57
A saluda le ponemos, este es despedir 00:35:59
Y al otro le ponemos 00:36:01
Y entonces al otro 00:36:02
Y a despide 00:36:05
Le ponemos 00:36:08
Saludar 00:36:11
Y aquí 00:36:13
eso 00:36:17
y aquí a despide le ponemos 00:36:21
despedir 00:36:24
bueno, pues ya hemos hecho un action perform 00:36:24
que ha necesitado acceder a tres 00:36:37
componentes de la interfaz 00:36:39
al texto para darnos el mensajito 00:36:40
y a los botones para intercambiar 00:36:42
el texto que tuvieran 00:36:45
si tenían uno le ponemos el otro 00:36:46
¿vale? entonces para poder 00:36:48
acceder a ellos, repito 00:36:51
como es imposible pasárselo por parámetros 00:36:53
solo hay una alternativa 00:36:55
que es que los tenga en la clase 00:36:56
un segundo, y para que los tenga en la clase 00:36:58
pues los tendremos que fijar con un setTest 00:37:00
o con un constructor 00:37:03
hemos hecho con un setTest porque era 00:37:04
el método que habéis empezado a apuntar 00:37:06
pero podría haber hecho un constructor 00:37:08
en el que le pasáramos los tres valores 00:37:10
y entonces ahora aquí en el main 00:37:13
no tendría que hacer los set 00:37:14
en el propio constructor se los paso los tres 00:37:15
y ya está, y me ahorro las tres líneas de abajo 00:37:18
¿vale? 00:37:20
sí, sí, pero 00:37:23
lo que importa es que 00:37:24
lo entendáis, ¿vale? podría haber 00:37:26
hecho un constructor aquí 00:37:28
con los tres parámetros 00:37:29
a ver, tú estás empeñado en que haga eso 00:37:31
a ver, venga, control shift 00:37:38
no me ha funcionado 00:37:40
alt shift s 00:37:44
ah, ya sé por qué a mí no me gustan 00:37:47
estos atajos, a ver 00:37:53
porque yo tengo esta mano encajada al revés 00:37:55
Entonces yo esta mano la puedo poner así 00:37:57
Para ponerla así tengo que subir todo el brazo 00:37:59
Entonces si a mí me dices que pulse dos teclas 00:38:02
Con esta mano me has matado 00:38:04
Porque no puedo, tendría que pulsarlas al revés 00:38:06
Entonces debe ser por eso, me acabo de dar cuenta 00:38:07
Por qué a mí no me gustan los atajos 00:38:10
Porque normalmente necesitan que uses esta mano 00:38:11
Va a ser por eso 00:38:13
Dime 00:38:15
¿Puedo mostrarlo aquí? 00:38:16
Sí 00:38:17
¿Cómo que nadie, todo el mundo ha entendido lo que ha pasado? 00:38:18
De que era 00:38:28
Y fue lo borrado 00:38:29
Bueno, pues aquí lo tenéis 00:38:30
A ver 00:38:33
Yo lo escribo rápido porque entiendo que lo vais haciendo 00:38:35
En paralelo vosotros 00:38:38
Que no necesitáis ver lo que yo escribo 00:38:39
Porque si yo os digo intercambiar un texto con el otro 00:38:40
Es que ya me lo sabéis hacer 00:38:42
No tenéis que ver lo que escribo yo 00:38:43
¿El cerebro? 00:38:45
Porque se tiene muy mala solución 00:38:49
Revisa llaves, revisa cositas 00:38:50
Vale, pues entonces 00:38:58
Todo esto de los atajos 00:39:06
Al final lo he hecho, fíjate por donde 00:39:07
A ver 00:39:09
Vamos a hacer el constructor 00:39:10
Vale, un constructor 00:39:12
Y ahora ya no necesito 00:39:16
Los sets, si no quiero 00:39:19
Podría pasárselos 00:39:21
Aquí, le puedo pasar 00:39:23
Aquí el texto 00:39:25
Saluda 00:39:26
Y despide 00:39:35
Espera, vamos a probar esto 00:39:38
Vale, si se lo paso por constructor 00:39:41
Pues me ahorro a hacer los sets 00:39:45
Pero bueno, la idea es la misma 00:39:46
La idea es que los necesita aquí arriba 00:39:47
¿Vale? 00:39:51
Bueno, pues 00:39:55
todo esto, el manejar estas cosas 00:39:56
con cierta soltura, el ir entendiendo el paso de parámetros 00:39:58
es lo más 00:40:01
importante en programación 00:40:03
¿vale? un segundín 00:40:04
vamos a ejecutar esto a ver si lo que hemos hecho 00:40:06
no tiene ningún error 00:40:08
esto no se va a ejecutar obviamente 00:40:10
vale, pues entonces aquí 00:40:16
efectivamente 00:40:21
Pues funciona el evento 00:40:25
Porque se van cambiando 00:40:27
Los textos 00:40:28
Y además 00:40:30
Me he puesto el mensajito correcto 00:40:32
Bueno, pues funciona correctamente 00:40:35
Problemas 00:40:38
Por ahora 00:40:40
Porque 00:40:43
Todavía seguimos 00:40:43
Cada componente, ¿te refieres a cada cosa? 00:40:46
Cada componente 00:40:55
Y luego el texto del botón es 00:40:56
claro, sí, pero no os preocupéis 00:40:59
que vamos a incorporar 00:41:01
un truco rápidamente 00:41:03
pero, bueno, vamos a descansar 00:41:05
dos minutos 00:41:07
por favor, pro 00:41:08
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:
12
Fecha:
8 de marzo de 2025 - 19:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
182.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid