Saltar navegación

20260505 EJER6_JAVAFX_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 5 de mayo de 2026 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Nuestro ejercicio 6. Utiliza un panel normal y corriente. En este panel vas a poner una etiqueta que diga coordenadas 00. Pues hasta ahí es fácil. Un panel limpio, mondo y lirondo. Y una etiqueta ahí puesta. 00:00:00
pues un panel mondo y lirondo 00:00:17
con una etiqueta en una esquinita 00:00:26
que ponga coordenadas 0, 0 00:00:28
vale, ¿va a pasar algo en esa aplicación? 00:00:30
sí, va a pasar 00:00:33
que cuando se desplace 00:00:34
el ratón, luego ya tenemos 00:00:36
un primer evento, el ratón 00:00:38
moviéndose, ¿sobre quién? 00:00:40
sobre el panel 00:00:43
luego ya vamos identificando 00:00:43
el que tiene que recibir el evento 00:00:45
es el panel, ¿qué evento? 00:00:48
que se mueva el ratón sobre él, vale, pues cuando se mueva el ratón 00:00:50
sobre el panel, yo tengo que poner en la etiqueta 00:00:54
label, las coordenadas del ratón 00:00:58
en ese momento, bueno, más o menos, entonces ya me hago idea, ah, pues 00:01:01
capturar algún evento de ratón en el panel, y en ese evento 00:01:06
sacar, habrá algunos métodos, esperemos, para sacar coordenadas del ratón 00:01:10
y esas coordenadas ponerlas en la label, vale, pues será eso 00:01:14
vale, más eventos 00:01:17
ah pues sí, si pulsamos 00:01:20
una tecla 00:01:23
se tiene que añadir 00:01:23
un botón 00:01:28
en la posición en la que 00:01:30
esté el ratón en ese momento 00:01:32
eso se me hace más raro, como saco yo la posición 00:01:34
del ratón a través 00:01:36
de un evento de teclado 00:01:38
si no tiene nada que ver, no voy a poder 00:01:40
del evento mouse event 00:01:42
puedo sacar todo relacionado 00:01:44
con el ratón en el momento en el que 00:01:46
produjo ese evento, como por ejemplo 00:01:48
la posición, pero del evento 00:01:50
key event que es pulsar una tecla 00:01:52
no voy a poder sacar una posición del ratón 00:01:54
entonces bueno, algo tendremos que pensar 00:01:56
bueno, pues como respuesta a ese evento 00:01:58
key event 00:02:00
tendremos que sacar la posición 00:02:01
del ratón a saber cómo 00:02:05
y crear un botón 00:02:06
con esa posición 00:02:08
con el texto de la tecla que hayamos 00:02:09
pulsado 00:02:12
vale, venga, pues hala 00:02:13
pues vamos a arrancar a hacer esto 00:02:18
aquí la escena 00:02:21
es mínima 00:02:24
un panel y una etiqueta, ya está 00:02:25
no hay más, entonces aquí 00:02:27
no vamos a matar moscas a cañonazos 00:02:29
haciéndonos con fxml 00:02:31
creándonos la escena, luego haciendo 00:02:34
con un controller, no, esa era una 00:02:35
capa que poníamos por 00:02:37
encima de la estructura básica 00:02:39
de JavaFX que ya hicimos 00:02:42
en el primer ejercicio por lo menos 00:02:43
o en los dos primeros, no lo sé 00:02:45
que era, yo tengo mi aplicación 00:02:46
en el que creo el panel, pongo componentes en el panel 00:02:49
y le añado escuchadores de evento a los componentes 00:02:53
esa es la estructura de JavaFX y no hay más 00:02:57
otra cosa es que cuando ya empieza a tener un montón de componentes 00:02:58
y la cosa engorda, puedo poner una capa por encima 00:03:02
una capa por encima 00:03:06
que me la dan las librerías de JavaFXML 00:03:08
que son unas librerías que hacen cosas por mí 00:03:11
entonces yo esas librerías 00:03:15
las importa, las importo 00:03:17
porque están en las dependencias 00:03:19
y que hago, me creo un fichero 00:03:20
xml y en ese fichero 00:03:23
xml le explico 00:03:25
lo que me da pereza hacer por código 00:03:27
porque son muchas cosas 00:03:29
se lo explico en ese xml 00:03:30
entonces en lugar de explicárselo 00:03:32
porque yo la sintaxis de sf 00:03:35
xml no me la puedo usar de memoria 00:03:37
afortunadamente tengo un software 00:03:39
que es el steam builder 00:03:41
que me permite arrastrando 00:03:42
crear ese fxml 00:03:44
entonces fxml es una explicación 00:03:46
de cuáles son mis controles 00:03:48
y con qué eventos 00:03:51
va a responder cada control, es una explicación 00:03:53
dada en un lenguaje extraño como es el fxml 00:03:55
y ahora las librerías 00:03:57
de fxml, las que hemos importado 00:03:59
desde maven, cogen esa explicación 00:04:01
y lo transforman 00:04:03
internamente en un código que ya sí 00:04:04
que responde al patrón que vimos 00:04:07
en los primeros ejercicios 00:04:08
entonces ahora cuando 00:04:11
trabajamos con fxml 00:04:12
estamos tapando todo eso, estamos poniendo una capa 00:04:14
por encima, pero lo de abajo no ha desaparecido 00:04:16
lo que pasa es que para no poner a mano 00:04:19
todo eso, pues venga 00:04:20
te lo explico con el fxml 00:04:22
que voy a poner y como va a responder cada cosa 00:04:24
te doy el fxml y tú librerías 00:04:26
de fxml 00:04:29
que están en las dependencias, tú ya construyes el código 00:04:30
eso es lo que estamos haciendo, poner un patrón 00:04:33
por encima, pero aquí 00:04:34
que tengo un panel y una etiqueta, pues no 00:04:36
lo vamos a hacer directamente 00:04:38
vamos a hacer a mano 00:04:41
Porque no somos tontos 00:04:42
Pues venga 00:04:44
Ala 00:04:46
Nuestra aplicación entonces está aquí limpita 00:04:47
Vamos a ver hasta donde llegamos 00:04:51
Pues venga 00:04:54
Me hago mi paquete 00:04:55
Para hacer la aplicación 00:04:56
Y aquí me voy a hacer 00:05:00
Mi clase aplicación 00:05:09
Con su método main 00:05:11
Vale aquí 00:05:18
acordaos de verificar 00:05:21
que en el pom que yo os de 00:05:24
en el plugin de fx 00:05:25
estará 00:05:31
puesto la clase 00:05:33
que tiene el método main 00:05:34
entonces yo aquí habré puesto cualquiera, esta misma 00:05:36
seguramente, aseguraos 00:05:39
de que la clase en la que vosotros 00:05:41
tenéis vuestro main es la que está 00:05:43
aquí, vale, porque si la habéis 00:05:45
llamado de otra manera o la habéis puesto en otro 00:05:47
paquete, pues tendréis 00:05:49
que poner aquí esa 00:05:51
aseguraos, estaría o no estará 00:05:52
porque en vuestro caso no aplica 00:05:55
en mi caso 00:05:57
para no tener que cambiarlo al paquete 00:05:59
lo he llamado tal cual y a la clase 00:06:01
la he llamado tal cual, con lo cual no te voy a cambiar 00:06:03
nada 00:06:05
vale, bueno pues 00:06:06
entonces, si esto queremos que sea 00:06:09
el punto de arranque de una aplicación 00:06:11
JavaFX 00:06:13
tiene que heredar de 00:06:14
application, tiene que heredar 00:06:16
de aquí, y si hereda 00:06:19
de aquí, tiene que 00:06:23
implementar el 00:06:25
bueno, primero la importo, tiene que implementar 00:06:27
el método start 00:06:29
este, en el 00:06:31
método start es, en el que 00:06:35
construimos la escena 00:06:36
o las escenas 00:06:38
y añadimos 00:06:39
los eventos de respuesta 00:06:43
a los controles de esa escena 00:06:45
ahí hacemos todo eso 00:06:46
repito, que trabajamos con fxml 00:06:48
pues mi construir 00:06:51
la escena, en lugar de poner yo los 00:06:53
paneles, los botones 00:06:54
todo, mi construir la escena va a ser 00:06:56
oye, este es el fxml, construyétela tú desde aquí 00:06:58
¿vale? pero nosotros 00:07:01
aquí no tenemos fxml, pues venga 00:07:02
luego para que esta aplicación lance 00:07:04
recordad que tenemos que llamar al método 00:07:07
lance, pasándole los 00:07:09
hipotéticos argumentos 00:07:10
que haya aquí 00:07:13
vale, pues entonces 00:07:14
¿qué vamos a hacer aquí? 00:07:17
pues recordad que 00:07:20
aquí, esto lo vimos 00:07:22
en nuestra primera aplicación 00:07:24
ya vimos que 00:07:26
teníamos que crear una escena 00:07:28
y ahora ya fijar 00:07:30
a mi escenario, a mi stage 00:07:32
esa escena y hacerla 00:07:34
visible, entonces teníamos 00:07:36
que crear aquí una escena 00:07:39
que esto 00:07:40
se creaba así, verdad 00:07:45
ay la madre que te trajo 00:07:48
que llevo diciendo 20 minutos 00:07:54
que tenemos 00:07:57
dos posibilidades, construir la escena 00:07:58
a pelo 00:08:00
o explicar 00:08:01
lo que queremos en un fxml 00:08:04
y decirle aquí, este es el fxml 00:08:06
construyétela tú, o construirla a pelo 00:08:09
entonces, estamos en ese segundo caso 00:08:10
construirla a pelo, ¿vale? 00:08:12
¿qué pasa con el mundo y el hirondo? 00:08:17
¿es de algún meme vuestro 00:08:19
de estas gilipollezas que veis en TikTok? 00:08:20
porque él dice el hirondo y el hirondo 00:08:26
y a pelo 00:08:27
Pues no lo sé, vendrá del gremio. 00:08:33
Bueno, pues nada, ¿hay algo más que diga que tenga que repetir? 00:08:38
Tiramillas y tiramillas. 00:08:42
Ah, no, el tiramillas no suelo decirlo. 00:08:45
Bueno, pues entonces, la escena tenía que vamos a hacer a mano, 00:08:51
no cargándola de un XML, ¿vale? 00:08:56
No cargándola de un XML. 00:08:59
la escena 00:09:00
recordad que necesitaba 00:09:02
un nodo raíz al que aferrarse 00:09:04
y luego un tamaño 00:09:07
un tamaño, el tamaño yo que sé 00:09:08
400 00:09:10
400 00:09:12
esto es lo que necesitaba la escena 00:09:13
y ahora, este nodo raíz 00:09:16
normalmente que va a ser 00:09:18
un panel 00:09:20
la escena se aferra a un panel 00:09:21
y ya en ese panel ponemos las cositas 00:09:24
pues ese panel 00:09:26
que sea 00:09:28
me han dicho un panel normal y corriente 00:09:30
pues esto podrá ser, ¿no? 00:09:35
ala 00:09:41
y ahora a mi stage 00:09:41
a mi stage 00:09:44
le fijaba la escena 00:09:46
tendrá un método 00:09:47
setScene, le fijaba 00:09:49
la escena y ahora la hacía 00:09:52
visible o algo así, ¿verdad? 00:09:54
esto tenía un punto show 00:09:56
o tenía algo, sí 00:09:58
vale 00:09:59
pues ya tenemos 00:10:01
una escena asociada a un panel 00:10:03
vamos a ejecutar esto 00:10:06
a ver si hasta aquí vamos bien 00:10:08
como es un proyecto maven 00:10:09
recordad que no se ejecuta 00:10:12
a través de la máquina virtual 00:10:14
sino se ejecuta llamando a maven 00:10:16
y en la primera 00:10:18
ejecución le decimos 00:10:20
oye tú runas 00:10:21
maven build porque te ejecuto 00:10:24
a través de ti maven 00:10:26
maven build y él nos dice vale muy bien 00:10:27
y que quieres que haga yo 00:10:30
Pues lo que quiero que hagas es llamar 00:10:31
Al plugin JavaFX 00:10:33
Que te he puesto en el POM 00:10:35
En particular quiero 00:10:38
Que hagas run 00:10:39
Vale 00:10:41
A ver si hemos tenido suerte hasta aquí 00:10:42
Vale, pues ya está, este es nuestro panel 00:10:45
Que no tiene nada 00:10:51
Pues ahora ya vamos a empezar a añadirle 00:10:52
Los controles, que en nuestro caso es una etiqueta 00:10:55
Sin más 00:10:57
Y luego ya los eventos 00:10:57
Que son dos 00:11:00
Mouse event sobre el panel y keypress 00:11:01
sobre el panel 00:11:04
pues venga 00:11:06
vamos a ver 00:11:08
una etiqueta 00:11:10
new label 00:11:14
vale, inicialmente entiendo yo que el 00:11:24
constructor tendrá la opción de a la vez que 00:11:27
instancias ponerle ya un texto, aunque luego el texto 00:11:29
lo podrás cambiar con set text 00:11:31
y este texto de partida era 00:11:33
coordenadas 00:11:35
nos han dicho que de partida le pongamos 00:11:39
esto, o algo así 00:11:41
cuidado con todos los import que hagáis 00:11:43
a ver si a toda velocidad 00:11:51
importáis de cualquier lado 00:11:52
no, siempre tenéis que importar del 00:11:54
vale, y ahora tenemos que añadir 00:11:56
la etiqueta 00:11:59
a este de aquí 00:12:03
al panel, vale 00:12:04
entonces 00:12:07
este tendrá un 00:12:08
algún método 00:12:11
para poner el componente en una posición 00:12:21
concreta 00:12:23
que 00:12:24
setLayoutX y setLayoutY 00:12:26
no, a ver 00:12:31
a ver cuál es, si no lo 00:12:32
busco 00:12:38
sí, pero para ponerle 00:12:39
el componente 00:12:47
estos son los eventos 00:12:48
a ver, voy a mirarlo 00:12:55
que lo tengo 00:13:06
por aquí 00:13:09
Vale, aquí lo tengo 00:13:10
Ah, vale, vale 00:13:14
Que tengo que coger los estos 00:13:19
Vale, vale, tengo que coger los nodos 00:13:20
Y agregárselo como nodo 00:13:22
Vale, vale, entonces 00:13:24
Vale, entonces, a ver 00:13:27
Para añadir elementos al panel 00:13:30
Yo del panel 00:13:34
Cojo 00:13:37
Uy, este no, cojo su lista 00:13:39
veis el panel tiene 00:13:44
un método getChildren 00:13:50
que nos da la lista 00:13:52
de los elementos que tiene 00:13:54
ese panel, pues a la lista de elementos 00:13:56
que tiene, le voy a poner la etiqueta 00:13:58
¿vale? 00:14:00
estas cosas concretas, o sea cuando uno 00:14:02
tiene, lo que decíamos ayer, uno tiene 00:14:04
la idea de lo que 00:14:06
tiene que hacer, perfectamente acotado 00:14:08
de su diseño, lo que tiene que hacer 00:14:10
para una consulta concreta 00:14:11
pues hombre no puede ir ahí explorando 00:14:14
los métodos, buscando 00:14:16
sería lo ideal ir probando 00:14:18
pero una cosa muy concreta pues nos ahorramos 00:14:19
tiempo, se lo preguntamos a la guía y ya está 00:14:22
si es que no vemos 00:14:24
en el examen no obviamente, pero claro en el examen 00:14:26
no vamos a poner nada que tengáis que averiguar 00:14:28
vosotros, bueno pues 00:14:30
entonces este 00:14:32
me dice la ayuda que me dice 00:14:33
todos los nodos que están en ese panel 00:14:36
pues voy a añadirle 00:14:38
yo la etiqueta 00:14:40
¿vale? 00:14:42
pero a saber 00:14:44
donde nos la ha puesto 00:14:46
aquí no hemos hablado de posición en ningún momento 00:14:48
a saber donde nos la ha puesto 00:14:51
entonces 00:14:52
vamos a ejecutar 00:14:54
esto a ver donde me ha puesto la etiqueta 00:14:57
bueno, por defecto me la ha puesto en la posición 00:14:58
0,0, estupendo 00:15:10
vale 00:15:11
si yo quisiera ponerla en otra posición 00:15:12
tendría que averiguar 00:15:16
como cambiar la posición 00:15:18
de un componente 00:15:20
Y ahí mirando 00:15:21
Ya si que llegaríamos a ese método 00:15:23
Que estabais diciendo 00:15:25
SetLayout 00:15:26
Me dice, oye tu componente 00:15:29
Colócate en esta posición, vamos a imaginar que queremos 00:15:31
La posición 00:15:33
50 para la X 00:15:34
No, lo que yo quería 00:15:37
Es añadirle un componente a un panel 00:15:43
De tipo panel 00:15:45
Esto es otra cosa, esto es fijar 00:15:45
Claro, la posición de ese componente 00:15:49
Por ejemplo 00:15:52
Si yo le fijo a una etiqueta 00:16:02
A la etiqueta label que acabo de hacer 00:16:06
Le fijo estas coordenadas de posición 00:16:07
Y luego se la añado 00:16:10
Pues entiendo que me la va a poner en otro sitio 00:16:11
Vamos a ver 00:16:13
Aquí me la había puesto en el sitio por defecto 00:16:15
Que es 0, 0 00:16:17
Vamos a ver ahora donde me la pone 00:16:18
Efectivamente me la ha puesto en otra posición 00:16:21
Vale 00:16:29
Bueno pero nos gustaba 00:16:30
la que tenía, la posición 00 00:16:33
como es la por defecto, esto lo puedo 00:16:35
entonces quitar, ahí se queda 00:16:37
comentado 00:16:42
vale 00:16:43
bueno, pues ya tengo construida mi escena 00:16:44
ya no hay más nodos, ni más nada 00:16:48
que tenga que añadirle a mi panel 00:16:50
la etiqueta, todo lo que viene 00:16:52
ahora, es ahora capturar 00:16:54
eventos, aquí no hay 00:16:56
controller, ni hay nada, porque el controller 00:16:58
el controller, repito 00:17:00
es una clase que hacemos 00:17:01
para que la entiendan las librerías 00:17:04
de JavaFX y la conviertan 00:17:06
en lo que vamos a hacer nosotros ahora 00:17:08
a mano. Pero aquí no tenemos 00:17:10
a JavaFX ML 00:17:12
para decirle, oye tú, hazme 00:17:13
estos eventos, yo te paso los 00:17:16
métodos en el control y házmelos tú. 00:17:18
No, aquí no tenemos eso, como cual es lo que vamos a hacer nosotros. 00:17:20
Pues venga. 00:17:23
¿Qué eventos 00:17:25
queremos capturar? 00:17:26
El primero. 00:17:28
El propio panel 00:17:30
es un evento que va a recibir el panel, 00:17:31
no la etiqueta. Podría ser un evento 00:17:34
de la etiqueta, que cuando pinchemos en la etiqueta 00:17:35
pase algo, pero no es un 00:17:38
evento que va a recibir la etiqueta, es un evento 00:17:40
que va a recibir el panel, cuando se 00:17:41
mueva el ratón sobre el panel que pase 00:17:44
algo, vale, pues 00:17:45
como fijábamos la respuesta 00:17:47
a un evento, cuando 00:17:49
lo hacíamos a pelo 00:17:51
como Miguel 00:17:53
sin tener 00:17:55
FXML, que nos pone 00:17:57
un controlador, que es una especie 00:18:00
de capa donde yo lo pongo y él ya se lo 00:18:01
pues como lo hacíamos, pues cogíamos el componente 00:18:04
que iba a recibir el evento, en nuestro caso se llama root 00:18:08
y buscábamos aquí los métodos 00:18:10
set on bla bla bla 00:18:14
y estos métodos set on bla bla bla 00:18:15
me dicen todos los eventos que puede recibir 00:18:18
y yo le paso dentro el código de respuesta 00:18:22
pues tendremos que buscar aquí por el propio nombre 00:18:25
y por la ayuda, el que pegue al ratón moviéndose 00:18:28
¿vale? 00:18:31
pues si vamos aquí buscándolos todos 00:18:33
seton bla bla bla aquí 00:18:35
no se cuanto bla bla bla 00:18:37
veis no tiene 00:18:39
un set on action 00:18:42
porque el panel no tiene evento por defecto 00:18:43
recordad siempre que on action 00:18:45
es el evento por defecto de un componente 00:18:47
si esto en lugar de un panel 00:18:50
fuera un botón veríamos 00:18:51
un set on action porque el botón si tiene 00:18:53
un evento por defecto, este es un panel no tiene 00:18:55
evento, que se hace por defecto con un panel 00:18:57
ni idea, por eso no lo tiene 00:18:59
vamos a ver si tiene mover ratón 00:19:01
bueno, pues seguimos aquí bajando 00:19:03
bajando, tiene cosas 00:19:05
de ratón 00:19:09
pues tiene toda la pinta de que este 00:19:10
se adapta a lo que nos han dicho, cuando el ratón 00:19:13
se mueva, cuando has movido 00:19:15
el ratón, pues tiene toda la 00:19:19
pinta de que este es el evento 00:19:21
que salta cuando tú mueves el ratón sobre 00:19:22
ese panel, cuando tú lo mueves 00:19:25
por su nombre, este es el evento de cuando 00:19:26
tú entras con el ratón en ese panel 00:19:29
el evento de cuando tú sales 00:19:31
con el ratón de ese panel 00:19:33
pero este es el evento cuando tú lo mueves 00:19:35
pues este 00:19:37
es el que queremos 00:19:39
y ahora 00:19:41
ahora venía lo bonito 00:19:42
vale, que teníamos 00:19:49
que poner aquí 00:19:51
pues aquí teníamos que poner 00:19:52
un objeto 00:19:54
vale, que tuviera 00:19:56
dentro el método 00:20:01
que tuviera dentro implementado 00:20:02
el método con la respuesta 00:20:05
a ese evento 00:20:07
eso es lo que voy a poner ahí 00:20:08
una instancia 00:20:10
de una clase 00:20:11
que tuviera dentro 00:20:14
un método con la respuesta 00:20:16
a este evento 00:20:19
que en nuestro caso tendrá que ser 00:20:20
capturar las coordenadas del ratón 00:20:22
y ponerlas en la etiqueta 00:20:25
vale, pues entonces 00:20:26
vamos a hacerlo 00:20:29
primero limpio completo 00:20:31
y luego vamos a hacer la trampa 00:20:32
bonita con la programación funcional 00:20:35
que ya sabéis del otro día 00:20:37
vale, vamos a hacerlo primero 00:20:38
pues como es 00:20:40
de principio a fin, ya no digo más a pelo 00:20:42
porque os reís 00:20:45
bueno, pues entonces 00:20:47
yo necesito aquí un objeto 00:20:49
pues por ejemplo 00:20:51
lo voy a llamar new 00:20:53
captura 00:20:54
ratón 00:20:56
necesito un objeto new captura ratón 00:20:58
y necesito que este objeto 00:21:03
tenga dentro 00:21:05
el método con la respuesta 00:21:07
a ese evento de mover el ratón 00:21:10
lo estoy haciendo tal y como lo hicimos 00:21:11
cuando hicimos esto en el primer proyecto 00:21:13
vale, pues me tengo que hacer 00:21:16
la clase captura ratón 00:21:18
a ver, me la puedo hacer fuera 00:21:19
pero como es una clase 00:21:22
que se va a usar solo aquí 00:21:24
y se va a instanciar solo aquí 00:21:26
pues me la hago como clase interna, no pasa nada 00:21:27
me la hago como clase interna 00:21:30
fuera del método lógicamente 00:21:31
porque las clases internas están dentro de otras clases 00:21:33
pero fuera de métodos 00:21:36
pues bueno, me la hago aquí 00:21:37
que solo la uso aquí y ya está 00:21:39
pues venga, me la hago aquí como clase interna 00:21:41
captura 00:21:45
ratón 00:21:46
vale 00:21:48
entonces 00:21:50
¿qué habíamos dicho de esta clase? 00:21:52
pues que esta clase 00:21:55
para que 00:21:57
fuera una clase 00:21:59
que generara objetos 00:22:00
capaces de estar a la escucha 00:22:02
de eventos, que eso ya es jugar un papel 00:22:04
especial, pues para ser 00:22:06
clases capaces de estar a la escucha, de captura 00:22:08
de eventos, es decir, jugar ese papel 00:22:10
para que una clase pueda jugar un papel 00:22:12
especial, ¿qué tiene que hacer? 00:22:14
Implementar algo. 00:22:17
Entonces juega ya ese papel especial. 00:22:19
Pues en este caso el papel 00:22:21
que tiene que jugar es el de ser capaz 00:22:23
de escuchar eventos y manejarlos. 00:22:25
Pues lo que tiene que implementar 00:22:27
es una interfaz que se llama 00:22:29
EventHandler, que es la interfaz 00:22:30
que te da el papel de ser capaz de manejar 00:22:32
eventos, como su propio 00:22:35
nombre dice. 00:22:36
Entonces, implements event handler, si no me he equivocado. 00:22:38
Vale, event handler. 00:22:47
¿Me habrá hecho el importe correcto? 00:22:49
Sí. 00:22:50
Vale, como veis nos aparece en amarillito. 00:22:53
El amarillo ya es un aviso. 00:22:56
El amarillo me está diciendo, oye, lo de siempre. 00:22:59
O lo de casi siempre. 00:23:03
Event handler es una clase genérica. 00:23:05
Es decir, te estás convirtiendo en una clase capaz de capturar eventos, de capturar cualquier tipo de evento. Cuidado porque entonces aquí vas a poder generar efectos secundarios porque vas a poder confundir cosas. ¿Por qué no mejor me parametrizas al tipo de evento que estás capturando? 00:23:06
¿vale? ¿por qué no me parametrizas 00:23:30
al tipo de evento? ¿qué tipo de evento estamos capturando? 00:23:33
un evento de ratón 00:23:35
pues entonces la parametrizamos 00:23:36
a mouse event 00:23:39
pero has puesto el método 00:23:41
el método lo has llamado tal cual 00:23:56
se llama en esa interfaz 00:23:59
ahora lo vamos a poner de todas maneras 00:24:00
porque si no, ¿cómo sabe aquí? 00:24:03
y luego lo has instanciado aquí 00:24:05
yo le pongo es event 00:24:06
la fecha 00:24:09
y se lo pongo en todo 00:24:10
ya, claro, ya, pero es que tú 00:24:12
claro, sí, pero eso es lo siguiente 00:24:15
por partes, ¿vale? 00:24:17
entonces 00:24:20
pero hay que entender 00:24:20
lo que quiero es que entendáis de dónde viene ese landa 00:24:23
¿vale? entonces 00:24:25
bueno, pues ya está, esto ya es 00:24:27
una clase capaz 00:24:29
de escuchar eventos 00:24:31
y no cualquier evento, sino 00:24:33
además eventos de ratón 00:24:35
bueno, pues ¿qué pasa cuando una clase 00:24:36
implementa una interfaz? 00:24:39
que tiene que implementar los métodos vacíos 00:24:40
de esa interfaz, por eso me está avisando en rojo 00:24:43
pues vamos a avisarlo 00:24:46
vale, resulta que esta interfaz 00:24:48
tiene un único método vacío 00:24:52
eso ya no suena de la otra clase 00:24:55
interfaz con un único método vacío 00:24:57
interfaz funcional, vale, por ahora lo dejamos aparcado 00:25:00
pero ya sabemos que un interfaz con un único método vacío es una interfaz funcional 00:25:03
¿qué peculiaridad tiene una interfaz funcional? 00:25:06
que la puede implementar directamente poniendo una lámina 00:25:09
¿vale? eso es 00:25:12
pero en realidad es esto 00:25:13
vale, pues entonces 00:25:16
ahora yo aquí ya 00:25:17
sí que tengo que poner 00:25:20
el código de respuesta 00:25:21
a ese evento mover ratón 00:25:23
¿vale? pues vamos a hacerlo 00:25:25
¿qué tenemos que hacer aquí? 00:25:26
sacar las coordenadas 00:25:30
del ratón 00:25:32
en el momento que se produjo el evento 00:25:33
¿vamos a poder sacarlas? 00:25:35
Pues seguro, porque este objeto mouse event es el objeto que tiene dentro todo lo relacionado con el evento de ratón. Malo será que no tenga las posiciones del ratón en ese momento. Malo será. Vamos a cotillar a ver qué tiene el event dentro. 00:25:37
el event dentro 00:25:54
tiene un get x 00:25:58
y un get y directamente 00:26:01
que me da 00:26:02
que tiene toda la pinta de que me da 00:26:05
la posición del ratón 00:26:06
en el momento que se genere ese evento 00:26:08
vale pues 00:26:10
entonces lo que yo tengo es 00:26:11
lo voy a poner aquí aparte 00:26:16
aquí tengo 00:26:17
voy a 00:26:23
aunque esto es un double 00:26:26
voy a quedarme con la posición entera 00:26:27
para que se vea 00:26:30
para que luego 00:26:31
en la etiqueta no se vea tan feo 00:26:33
con todos los decimales 00:26:35
que no tengo que formatearlo a dos decimales 00:26:38
un rollo, me voy a hacer un casting aquí 00:26:40
y me quedo 00:26:42
con la posición y 00:26:44
y aquí me hago el casting 00:26:46
vale, estas son 00:26:58
las posiciones que tenía 00:27:04
el ratón cuando yo lo he movido 00:27:06
el evento ha saltado 00:27:08
y hemos llegado hasta aquí 00:27:10
¿qué es lo que hay que hacer? 00:27:11
pues poner estas posiciones 00:27:14
en el texto de mi etiqueta label 00:27:16
poner esas posiciones en el texto de mi etiqueta label 00:27:19
es decir, hacer aquí algo como esto 00:27:23
label.sectest 00:27:25
coordenadas pero en lugar de 00 00:27:32
esto lo vamos a cortar por aquí 00:27:48
para que sea posición x 00:27:52
el guión otra vez 00:27:54
y aquí cortamos 00:27:58
para que en lugar de 0 00:28:02
ponga posición y 00:28:05
y aquí ya concateno 00:28:07
con el final del 00:28:09
este 00:28:10
y aquí me falta un paréntesis 00:28:13
vale, coordenadas 00:28:18
posición x y en posición 00:28:19
y mayúscula 00:28:21
¡Hala! Pues todo estupendo 00:28:25
si no fuera porque el label no es visible desde aquí 00:28:26
¿verdad? 00:28:29
todo magnífico 00:28:31
el evento ya está completo, coge las 00:28:32
coordenadas del ratón en el momento 00:28:35
en el que se produjo el evento 00:28:36
me las pone aquí 00:28:38
en la etiqueta 00:28:40
pero tengo un pequeño problema 00:28:42
que mi etiqueta label no es visible 00:28:44
desde aquí porque mi etiqueta label 00:28:46
es un método local de start 00:28:48
luego tengo 00:28:51
un pequeño problema 00:28:53
si lo quiero hacer así 00:28:53
¿cómo lo podríamos hacer? 00:28:55
muy fácil 00:29:00
antes que eso 00:29:01
claro 00:29:05
el problema que tengo es que tengo que acceder 00:29:09
desde aquí a esta variable 00:29:12
que es local de este método 00:29:13
solución natural 00:29:14
que es de hecho la que adoptan los 00:29:18
frameworks de, se la inyecto por 00:29:21
constructor, inyección por 00:29:23
constructor, es 00:29:25
que necesito en un método local de una 00:29:27
clase algo, o en 00:29:29
varios, propiedades 00:29:31
de la clase que inyecto por constructor 00:29:33
solución general para muchas situaciones 00:29:35
de este tipo, que 00:29:37
necesitas una etiqueta 00:29:39
Ah, pues no pasa nada, inyectamela 00:29:40
Yo la pongo aquí 00:29:42
Esta es la que voy a usar 00:29:43
Y tú inyectamela, por Dios 00:29:45
Cuando me instancies 00:29:48
¿Vale? Esto se llama inyección por constructor 00:29:49
Que es una arquitectura natural 00:30:09
En una situación en la que nos veamos así 00:30:12
Ahora 00:30:13
Este ya 00:30:15
Sí que va a acceder a la que le hemos 00:30:17
Inyectado por constructor, que será esta 00:30:19
Pero claro, inyectémosela bien 00:30:21
Claro 00:30:23
vale 00:30:26
pues este evento ya está 00:30:30
vamos a ver 00:30:32
si esto nos funciona 00:30:34
ay que rapido 00:30:38
vale pues si nos funciona 00:30:40
pero efectivamente 00:30:47
y paramos ahora antes de hacerlo 00:30:52
pero efectivamente 00:30:54
diríamos jolines 00:30:56
tengo que hacer una clase 00:30:57
para cada evento poner el método 00:30:59
de inyectar las cosas y tengo que inyectar un montón 00:31:01
me queda aquí un montón 00:31:04
de componentes 00:31:06
y un montón de clases 00:31:07
pues hombre, entonces ahí es cuando 00:31:10
decimos, a ver, ¿para qué se ha inventado 00:31:11
la programación funcional? 00:31:13
¿Qué es EvenHandler? 00:31:16
Una interfaz funcional 00:31:17
porque solamente tiene un único método 00:31:19
vacío, un único método 00:31:22
que es Handler 00:31:23
¿Cómo podíamos instanciar 00:31:24
objetos de interfaces funcionales 00:31:28
sin necesidad de hacer una clase 00:31:30
aparte y ya instanciar ese objeto 00:31:32
pues me hago una función 00:31:34
lambda sintácticamente correcta 00:31:36
que represente 00:31:38
el código de este método 00:31:40
y esa función lambda 00:31:42
la planto aquí y esa función 00:31:44
lambda ya me está instanciando 00:31:46
un objeto en particular 00:31:48
de esta interfaz funcional 00:31:50
e implementándome ese método 00:31:52
¿vale? 00:31:54
pero paramos un segundito aquí 00:31:56
y ahora lo hacemos después 00:31:58
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:
2
Fecha:
5 de mayo de 2026 - 12:37
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
126.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid