Saltar navegación

GUI- Listener y adapter - 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 11 de marzo de 2025 por Stefano C.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, ya estoy grabando. Si alguno de vosotros habla y demás, me da permiso para que se grabe. 00:00:02
Y nada, el otro día, bueno, estos últimos días os habéis estado haciendo ejercicios, 00:00:10
hemos estado viendo algo de teoría y sobre todo habéis visto eventos, 00:00:18
lo que son los listeners y sé que estáis todos encantados con esto, 00:00:23
tanto como que hoy habéis estado viéndolo en Javascript. 00:00:27
Y bueno, no sé qué os gusta más o qué os interesa más, si Javascript o manejar los eventos con Java, pero bueno, al final, como estáis comprobando, se trata todo el rato de poder hacer acciones con los componentes que nos ofrecen las interfaces gráficas de estos lenguajes. 00:00:31
Entonces, bueno, aquí, aunque ya he visto que algunos los estuvisteis manejando, lo que voy a explicar ahora, los estuvisteis manejando algunos, también un poco por recomendación de Estefano, y bueno, pues hasta ahora hemos estado trabajando con el Action Perform, es decir, con el Action Listener, con la interfaz. 00:00:53
siempre lo hemos enfocado a un botón de un tipo, a un botón en concreto o a otro componente diferente 00:01:16
en este caso lo que quiero que veáis es que también se puede hacer de una forma genérica 00:01:27
es decir, vamos a poner un ejemplo en el cual independientemente del botón que tengamos 00:01:32
se puede hacer una acción, es decir, se puede controlar simplemente por el tipo de componente, ¿no? 00:01:39
Entonces, abriríamos aquí, a ver, new, other, JFrame, ¿vale? 00:01:49
Y le daríamos, aquí tendríamos una pantalla, lo que es un JFrame y vamos a añadirle un par de botones, ¿vale? Un botón mismamente, con un botón sería suficiente, pero bueno, vamos a darle en par. 00:02:03
Primero recordar, siempre teníamos el flow layout de lo que es el panel 00:02:40
Lo vamos a poner genérico para poder mover nuestros botones 00:02:48
Vamos a copiar 00:02:53
Recordar siempre esto 00:03:12
Aquí ya lo va poniendo, se van actualizando los nombres 00:03:29
aquí en este caso no bueno lo cambiamos como os fijáis bueno si os fijáis en estos días cuando 00:03:34
nos vamos al código obviamente ya se han creado por aquí los botones perdonar que esto está muy 00:03:54
grande y yo me cuesta un poquito manejarme pero si no lo veis a ver si lo veo aquí tenemos el 00:03:58
botón aceptar y el botón cancelar entonces para recordar que para poder utilizar el lo que son 00:04:04
los eventos de esos mismos se ven de esos mismos componentes podríamos hacer dos cosas una hacer 00:04:13
doble clic en él en dichos en dichos componentes y que nos muestre lo que es el propio método ya 00:04:18
de la interfaz dentro de nuestro código es decir si apretamos a aceptar vale ya nos crea aquí el 00:04:27
el AddActionListener con el ActionPerform, que es donde vamos a meter la acción que queremos. 00:04:36
Pero queremos manejarlo todo de forma genérica y como recordaréis, 00:04:43
habíamos hablado de hacerlo a través de implementar directamente 00:04:48
lo que era la interfaz ActionListener. 00:04:55
Vale. Si os fijáis, lo que os explicaba ayer a algunos, que parecía que no lo teníais muy claro, lo recuerdo ahora un poco, era el tema de que, bueno, ActionListener, en este caso, que es el, bueno, pues el escuchador con el que vamos a poder trabajar con nuestros eventos, digamos que esto es una interfaz. 00:04:58
y como buena interfaz, pues tiene una serie de métodos obligatorios que tenemos que implementar en nuestro código. 00:05:28
Obviamente aquí nos está dando un error, que si nos colocamos encima vamos a poder ver que efectivamente 00:05:37
nos está dando un mensaje diciendo que obviamente faltan estos métodos. 00:05:43
Entonces los añadimos aquí y entonces aquí abajo vamos a tener ya lo que sería el action perform, que es donde vamos a poder meter o donde vamos a poder incluir todas las acciones o todo el, bueno, todo el procesamiento que queremos hacer cuando recojamos el evento de nuestro componente, ¿vale? 00:05:51
Entonces, para poder llamar nosotros a dicha interfaz, tendríamos que, obviamente, añadirle, perdonad que es que me manejo fatal con este, aquí tenemos la opción del Add Action Listener y como lo estamos llamando desde nosotros mismos y va a afectar a nosotros mismos, le ponemos el Dish, ¿vale? 00:06:16
Es decir, al botón aceptar. 00:06:43
Y lo mismo vamos a hacer con el botón cancelar. 00:06:46
Cancelar. 00:06:54
Punto. 00:06:55
Add. 00:06:58
Action listener. 00:07:00
Y le ponemos el this. 00:07:02
Perfecto. 00:07:07
Entonces, ahora con esto, ¿qué hacemos? 00:07:09
Cuando realmente nosotros estamos haciendo un click o cualquier evento sobre, 00:07:11
Vamos a poner que es otro tipo de componente, que no es un botón. 00:07:15
Bueno, pues cuando se hace un clic, realmente lo que estamos haciendo al hacer esta llamada 00:07:20
es, digamos, implementar directamente lo que es la interfaz del ActionListener, 00:07:26
de tal modo que nos va a llevar a su método ActionPerform. 00:07:33
¿Ok? Entonces aquí nosotros, si veis aquí, bueno, vamos a controlar ahora los dos tipos de botón. Acordaros también, aquí este parámetro en el action event, si os fijáis aquí le estamos pasando el dis de parámetro, es decir, le estamos pasando un botón cancelar un tipo botón, ¿vale? 00:07:37
Entonces, aquí, este sería, digamos, el botón que le vamos a pasar a nuestro evento. Entonces, para controlar, vamos a ver, recordar que lo hacíamos de tal modo que, equals, y le damos, por ejemplo, botón aceptar. 00:07:58
Vale, sí. Vale, entonces, ¿con esto qué estamos haciendo? Estamos haciendo realmente que nos esté preguntando, digamos, antes de empezar a hacer nada, nos está preguntando si realmente lo que le estamos mandando es un botón y si es el botón aceptar, ¿vale? 00:08:32
entonces aquí estamos viendo que nos está dando un error como bien os disteis cuenta algunos el 00:09:07
otro día nos tenemos que dar cuenta que nosotros cuando lo hemos creado automáticamente se nos ha 00:09:14
generado estos botones dentro del constructor ejemplo genérico por lo tanto habría que tenerlo 00:09:20
aquí abajo, tendríamos que tener inicializados lo que son tanto el botón cancelar como el aceptar, aquí ya lo tendríamos creado y aquí ya no nos da el error, ahora haríamos un save y haríamos lo mismo con el botón cancelar, perfecto. 00:09:29
también estuvimos hablando de que podíamos pintar o bien por consola o bien pintar en algún otro tipo de componente 00:10:34
de tipo texto o label o alguna historia así. 00:10:44
Vamos a ponerle, por ejemplo, yo en el ejemplo le había puesto un textarea, pues bueno, vamos a ponerle un textarea 00:10:46
o un campo de texto, el que más rabia nos dé. 00:10:56
Mira, vamos a ponerlo en JTextField y se lo vamos a poner aquí. 00:11:03
Vamos a poner aquí, recordar siempre darle vuestro propio nombre 00:11:09
con el prefijo del componente que vayáis a utilizar. 00:11:14
Esto os va a ser muy útil, sobre todo cuando estéis trabajando, 00:11:20
como decía Estefano, cuando sois unos profesionales de la programación 00:11:23
Y obviamente tengáis un formulario con 200 campos 00:11:26
Entonces si no, nos vais a enterar 00:11:31
Entonces siempre está bien ponerle un campo 00:11:33
Entonces, aquí se nos ha creado el texto resultado 00:11:37
Acordaros siempre también que 00:11:44
Este mensaje que no dice absolutamente nada 00:11:59
Pero nos vale 00:12:13
Y aquí inicio, y aquí cancelar. Hasta aquí, esto es un poco todo lo que hemos visto y aquí controlaríamos cuál es el tipo de botón. De hecho, vamos a pulsarle, debería funcionar, cuando pulsamos aquí, bueno, he hecho muy pequeño la caja de texto, cuando le damos aquí, cancelar pulsado, aquí aceptar, bueno. 00:12:15
Es decir, esto quedaría, pero nosotros ahora lo que vamos a querer es, por ejemplo, que siempre, que cualquiera de los dos botones, nos da igual cual sea, siempre que se pulse, que quede desactivado, por ejemplo. 00:12:50
¿Vale? Entonces para ello, si os fijáis aquí, bueno, hemos generado un código, que vais a ver ahora, le vamos a llamar click button, ¿vale? Y aquí lo que le vamos a decir es que cuando el elemento, es decir, el componente que está llamando a la interfaz sea de tipo JButton, es decir, 00:13:08
Ah, por el A, perdón. Es que parece mentira, pero con tenerlo tan grande me cuesta bastante más verlo que si lo tuviera más pequeño. Vale. Y entonces, a este click, uy, a este click button, le podemos poner la setEnable, con el poniéndole la propiedad Enable a false, lo que estamos haciendo es que se quede desactivado, ¿vale? 00:13:49
Entonces, ahora si lo generamos, cuando a nosotros le damos al botón aceptar, efectivamente nos hace toda esta funcionalidad independiente, pero luego de forma genérica, simplemente por el hecho de ser un botón, se nos deshabilita. 00:14:53
Y lo mismo nos va a pasar con el cancelar, cuando le damos se nos deshabilita, si os fijáis no lo estamos metiendo dentro de la condición sino después, es decir, de una forma genérica, lo que estamos afrontando es el tipo de botón, o sea, el tipo de componente que le estamos pasando. 00:15:17
vale tener en cuenta que claro siempre el tipo que va a tener un tipo de propiedades x que nos 00:15:37
van a salir a cuenta es decir en este caso tenemos el set en ablett que esto pertenece 00:15:45
a los componentes jota button vale alguna duda con eso más o menos luego en los ejercicios que 00:15:51
hagamos podéis aplicarlo que lo vais a tener todavía esta parte creo que no está subida 00:16:06
los apuntes o lo voy a subir luego al aula virtual para que podáis tenerlo y cuando estáis haciendo 00:16:11
luego ejercicios podáis seguirlo y aplicarlo o bien me lo preguntáis amigo estefano vale 00:16:18
papá 00:16:26
simplemente el interfaz de ese modo se pueden implementar diferentes 00:16:32
diferentes componentes y se ordenan las clases de tal modo que unas bueno esto lo que queremos 00:16:36
decir es que se pueden crear hasta ahora hemos creado todo el tiempo 00:16:43
como decirlo clases en una misma clase hemos incluido lo que era la interfaz hemos metido 00:16:51
el listener y hemos pintado por pantalla es decir hemos hecho todo todo en una misma en 00:16:58
una misma clase pero al igual que habéis hecho con otros proyectos hasta ahora se puede hacer 00:17:05
en diferentes en diferentes clases unas que manejen lo que sería el evento y otras que 00:17:11
pinten pues lo puesto todo lo que hayamos procesado no vamos a ver por ejemplo aquí 00:17:16
Y vamos a hacer un ejemplo listener y un ejemplo normal, ¿vale? 00:17:25
Entonces, vamos a ver, aquí vamos a meter, por ejemplo, en el, vamos a hacer un ejemplo, ¿cómo le llamamos? 00:17:33
Soy malísimo poniendo nombres 00:17:51
Si a alguien se le ocurre alguno un poquito mejor 00:17:58
Que lo diga y lo pongo, ¿vale? 00:18:02
Para nuestro ejemplo 00:18:05
Vamos a añadir simplemente un botón, ¿vale? 00:18:17
De momento 00:18:24
Volvemos a utilizar el 00:18:25
Volvemos a poner dentro de lo que es el panel 00:18:32
el layout en absoluto vamos a colocar un botón por llamarlo de alguna manera no os penséis que 00:18:35
voy a hacer un juego y ahora nos vamos a hacer una clase ejemplo listener 2 vale que va a ser 00:18:52
bueno es que no sé si llamarlo así venga si lo vamos a llamar así 00:19:21
Sé que no es un gran nombre, pero no me habéis dado más ayuda, pues le llamamos ejemplo Listener 2. 00:19:24
Si os fijáis en el ejemplo Listener 2 00:19:40
Le vamos a hacer una implementación al ActionListener 00:19:50
A lo que sería la interfaz de la que hablábamos 00:19:55
Para que se nos genere el ActionPerform 00:19:58
Y ahí poder ejecutar todo 00:20:00
Entonces vamos a hacerle 00:20:02
El ImplementsActionListener 00:20:09
¿Qué estoy poniendo yo mal? Ahora, le añadimos los métodos que necesita implementar, por lo que hablábamos antes, de que es una interfaz, se nos genera aquí abajo, no lo veo, aquí, y aquí vamos a hacer el mismo caso del botón deshabilitado, ¿vale? 00:20:17
un botón vamos a aquí importar el botón que no tiene vale y entonces tenemos un punto 00:20:55
se tenable 00:21:57
ya tendríamos lo que tal y como lo hemos enseñado antes pero distribuido en dos en dos en dos clases 00:22:05
una que recoge y otra que digamos procesa todo pero si nos damos cuenta no tenemos la llamada 00:22:19
del botón que hemos creado en la pantalla que pinta no tenemos no hemos hecho ninguna llamada 00:22:30
todavía al listener que está en la otra clase entonces para ello un juego acción listener y 00:22:36
Y entonces le vamos a llamar el ejemplo listener2, que es este de aquí. 00:22:54
Vamos a llamarle aquí a este, si no me equivoco. 00:23:04
Ta, ta, ta, ta. 00:23:10
¿Veis? Aquí lo tenemos. 00:23:11
Uy, lo tenemos aquí, ¿vale? 00:23:12
Le vamos a hacer una interfaz aquí. 00:23:14
Aquí nos está dando error. 00:23:16
Entonces, en un principio, debería funcionar de tal manera que cuando pulsamos se nos deshabilita. 00:23:28
¿Vale? Es decir, lo mismo que hemos hecho antes con una misma clase, estaría, vamos, sí que es conveniente poder dividirlo en diferentes clases. 00:23:37
¿Por qué? Pues porque siempre va a quedar de una forma más organizada, incluso puede haber listeners que nos sirvan para diferentes formularios. 00:23:50
Es decir, nosotros podemos tener una funcionalidad que en nuestro programa tengamos tres formularios a los que accede el usuario, pero siempre que apretamos ese botón va a ser que recoja esos datos y que los guarde. 00:23:58
Bueno, pues eso tendríamos una clase listener que cogería todos esos datos de los diferentes formularios, bueno, del formulario que le llame y del componente en concreto del formulario y lo procesaría para cada uno de ellos, ¿vale? 00:24:14
Y, vale, y entonces, no os preocupéis que la teoría ya va prácticamente a terminar, ¿vale? Aquí, bueno, os pongo un ejemplo que es el mismo que hemos hecho. 00:24:32
Vale, hasta ahora hemos estado viendo el ActionListener y como bien decíamos es una interfaz 00:24:41
Y todas las interfaces tienen una serie de métodos obligatorios, que eso ya sé que lo sabéis todos 00:24:54
Y entonces tienen una serie de métodos obligatorios que hay que implementar sí o sí, ¿vale? 00:25:03
Entonces, por ejemplo, en este caso tenemos el escuchador WindowListener, que esto lo que hace referencia es a una serie de métodos con las que podemos trabajar, por ejemplo, con la ventana, es decir, con todos los elementos que tengamos en la ventana. 00:25:09
Si os fijáis, tenemos el método WindowClosing, el Opened, el Closed, el Iconified, el de Iconified, Activated y de Activated, ¿vale? 00:25:29
Con esto lo que quiero decir es que no solo está el ActionListener, hay muchos tipos de Listener, es decir, en el caso de los botones y demás, pues sí, utilizamos el Action, 00:25:43
Pero, en el caso de las ventanas, por ejemplo, pues vamos a manejar el Windows Listener. 00:25:53
Vale, vamos a poner un ejemplo, si os parece, del Windows Listener, cómo se implementa y, bueno, meter una pequeña funcionalidad. 00:26:00
Entonces, aquí tendríamos, ejemplo, Windows Listener, pa, pa, pa, pa. 00:26:11
Vale, ta, ta, tam, vale, entonces. 00:26:41
si encuentro donde estamos 00:26:51
aquí en este ejemplo que os he puesto nosotros se supone que hemos generado un proyecto tipo 00:26:56
es decir una clase que no es tipo frame que es mi caso vale aquí lo hemos hecho creo que 00:27:08
creo que se llama windows cuando vamos a abrir una por ejemplo cuando vamos aquí y queremos crear una 00:27:16
cuando le damos al other cuando tenemos el swing designer podemos hacerle una aplicación windows 00:27:21
o un jota frame en mi caso yo he abierto directamente un jota frame vale esto qué 00:27:27
quiere decir pues que aquí en el código si os fijáis cuando lo abrís como como una acción 00:27:32
windows se llama acción windows y creo que sí pues tenemos que declarar también la ventana 00:27:38
etcétera cuando lo hacemos de la forma en la que estamos ya se supone que estamos partiendo 00:27:44
de la ventana es decir las propiedades ya funcionarían es decir aquí si no me equivoco 00:27:49
window 00:27:57
debería ser así 00:28:01
vamos a importar el windows listener 00:28:17
porque no me dejas 00:28:31
en un instante obviamente esto va a ser 00:28:45
Create a frame 00:29:19
Set content panel 00:29:30
¿Se te ocurre, Estefano, por qué puede ser esto? 00:29:38
¿Por qué no me está permitiendo? 00:29:47
¿Él? 00:29:53
Sí 00:29:56
Así es que 00:29:56
No, pero esto se supone que es aquí 00:29:58
A ver, ta, ta, ta, ta 00:30:01
Vale, pa, pa, pa, pa 00:30:06
Sí, efectivamente 00:30:07
Este es así 00:30:08
El paréntesis de abajo es este 00:30:11
vale, porque no hemos implementado los métodos, vale, esto era lo que quería, perdona que estoy yo un poquito dormido hoy 00:30:16
bueno, como hablábamos antes, si os fijáis, aquí anteriormente teníamos todos estos métodos 00:30:33
que son los que implementa la interfaz Windows Listener, ¿vale? 00:30:42
Antes teníamos acción Listener, ahora Windows Listener y nos obliga a implementar todos estos eventos, ¿vale? 00:30:46
En un principio no tenemos por qué generar ningún tipo de acción en todos los métodos, 00:30:55
es decir, simplemente los que nos vayan a servir. 00:31:04
Por ejemplo, vamos a hacer un ejemplo con el window closing, ¿vale? Entonces, aquí, ¿veis? Aquí os explicamos, siempre se implementa la interfaz window listening y se incluyen los métodos obligatorios que requiere. 00:31:09
vale y entonces aquí en el windows closing vamos a añadirle por ejemplo 00:31:25
ventana una ventana nueva 00:31:42
si os fijáis aquí también tenemos el get source igual que lo teníamos en él en él 00:31:59
en el acción listener con él con el acción proceed pues se le pasa siempre el componente 00:32:04
por aquí y para obtener el el componente en sí lo hacemos con el que todos aquí lo 00:32:16
castigamos para que se quede común de este tipo 00:32:23
y aquí vamos a ver algo que de momento no hemos visto que se trata de los option pane bueno yo 00:32:30
creo que alguien sí que ha estado utilizando estos días alguna opción pane tuvo en el bus 00:32:42
caminas no lo utilizaste o alguien alguien de bueno me sonaba que alguien había había 00:32:46
aquí le vamos a dar su opción vale su opción bueno el jota opción pane y el show opción 00:33:05
dayal o a lo que hacen referencia realmente bueno es un tipo de componente en el cual nosotros vamos 00:33:26
a poderle mostrar mensajes al usuario en función de lo que vayamos haciendo son ventanitas que se 00:33:33
le van a se le van a abrir y entonces pues le van a dar diferentes opciones pues quieres hacer no 00:33:41
sé qué aceptar no cancelar y en función de las elecciones que hagamos de y en función de cómo 00:33:47
lo configuremos pues vamos a tener la posibilidad de llevar nuestro código de una manera o de otra 00:33:55
para que bueno pues para hacer diferentes acciones en función de lo que se haya seleccionado vale si 00:34:04
os fijáis tiene un montón de un montón de parámetros y bueno vamos a ir viendo los 00:34:10
diferentes vale aquí por ejemplo el primer parámetro es el option panel sobre qué elemento 00:34:19
sobre la ventana, que es el JFrame de tipo ventana que hemos creado antes, ¿vale? 00:34:26
Luego le vamos a poner el mensaje, por ejemplo, seguro que quieres salir, 00:34:34
pues le vamos a poner aquí en el segundo parámetro, como podéis ver soy súper original 00:34:39
con el tema de los mensajes, ¿vale? 00:34:59
Le vamos a poner cuadro de confirmación, esto es un texto que nos va a venir arriba, 00:35:06
lo encuentro que se me ha ido por aquí, aquí en el get title le vamos a poner, luego a continuación le vamos a dar en el joption panel tiene diferentes, bueno igual que con los paneles y los contenedores, teníamos los layouts y en función del tipo de layout si le poníamos un grid no salía tipo tabla o bueno en fin, o el flow layout que salía todo seguido, 00:35:11
aquí podemos utilizar el yes no option por ejemplo y entonces nos va a dar la opción de sí o no directamente, entonces para esto, ponemos aquí, como era, con el jOptionPanel, veis aquí tenemos diferentes opciones, por ejemplo, yes no option, yes option, yes no cancel option, en este caso le vamos a dar a yes no, vale, 00:36:12
Luego le vamos a dar el question message, que es como que le va a aparecer, bueno, es otro tipo de, bueno, de plantilla que tiene para poder mostrar la pregunta. 00:36:54
Question Message, aquí está, os fijáis, antes de darle a Question Message, aquí tenemos un montón de opciones, Cancel Option, Closed, Default, un mensaje de error, bueno, un mensaje de warning, bueno, podéis, o sea, tenéis infinidad de plantillas y de opciones. 00:37:06
vale cuando está seleccionado cuando no en fin ahí hay un montón de hay un montón de opciones 00:37:48
que al final no la he puesto y hemos dicho que era cuestión meses en la cuestión meses y luego 00:37:59
los últimos campos los vamos a poner a null vale porque no nos van a hacer falta los últimos 00:38:13
parámetros a ver que se me ha vuelto a mover entonces ahora nosotros vamos a vamos a manejar 00:38:23
este jota opción panel vale lo vamos a lo vamos a manejar y vamos a poder controlar las diferentes 00:38:48
acciones que queramos en este caso lo que vamos a querer es cerrar la pantalla vale entonces 00:38:56
hemos dicho que le dábamos al 10 opción 00:39:03
y no, System.exe 00:39:26
vale, ahora si le damos a funcionar 00:39:59
pues vale, hay algo que nos está dando error, vamos a ver 00:40:10
¿dónde? ¿aquí? no, porque es que incluye el este 00:40:16
no, aquí no sería, no, no, porque entonces nos falla 00:40:32
no, está diciendo que le faltan los 00:40:35
que le falta implementar los métodos, pero claro, si le doy 00:40:39
me va a implementar todos otra vez, vamos a ver si es que tenemos algo aquí mal 00:40:44
como no veo todo bien 00:40:48
vale, vamos a ver si está dando ningún error 00:40:51
aquí, ah vale, ahora sí 00:40:58
ahora ya debería cogerlo bien 00:41:07
gracias, de todas maneras, pero 00:41:10
Vale, vamos a ver si no nos da error ahora, vale, entonces si nosotros le damos aquí, veis, nos aparece este mensaje, seguro que quiere salir, si le damos al yes, nos cierra el programa, vale, es decir, los Jpanel son muy, bueno, son muy importantes y demás, 00:41:14
pero al final, o sea, los Joption, pero realmente aquí lo que quiero que veáis es que estamos manejando otro tipo de listener, ¿vale? 00:41:41
De otro tipo de interfaz, que es el WindowListener, ¿vale? 00:41:56
Entonces, además del WindowListener, la cosa se puede poner un poquito más complicada y tenéis diferentes tipos, hay multitud, ¿vale? 00:42:00
hay multitud de listeners para poder manejar diferentes diferentes componentes esto obviamente 00:42:10
en este curso no los vais a estudiar no vais a tal pero sí estaría bien que cuando os toque 00:42:19
manejar alguno tengáis siempre en cuenta una cuestión una cuestión cualquiera de ellos es 00:42:24
igual que la acción listener o como el windows que acabamos de ver y eso se trata de interfaces 00:42:30
Y todos implementan una serie de eventos que vais a poder utilizar, o sea, una serie de métodos obligatorios con los cuales vais a poder hacer un montón de cosas. Es decir, esto os abre multitud de opciones. 00:42:35
Por ejemplo, el KeyListener. El KeyListener es, ayer alguien me preguntó, cuando una caja de texto, cuando nos ponemos encima de una caja de texto y alguien le da al Enter, ¿cómo registramos ese evento? ¿Cómo se puede hacer algo? 00:42:53
Bueno, pues eso sería con el KeyListener, ¿vale? De hecho, la persona que me lo preguntó, no sé quién fue, nadie, nadie, yo es que tengo muy mala memoria, tal vez no recuerdo, pero bueno, le invito a que lo pruebe hoy con alguno de los ejercicios que hagamos a continuación. 00:43:09
Y luego, por ejemplo, también tenéis el mouse listener, que pues esto es para poder manejar todos los eventos que puede generar o que se pueden llevar a cabo con un ratón, ¿vale? 00:43:28
Y luego aquí abajo hay una nota que es importante y es que el mismo componente gráfico puede implementar varios listeners, varios diferentes tipos de listeners, ¿vale? 00:43:46
Vale, ¿qué sucede? Como hemos visto aquí, aquí cuando hemos creado el WindowListener, de repente tener que implementar todos estos métodos, pues sí, está muy bien, es estupendo, es una interfaz, nos obliga, 00:43:55
Pero si no vamos a utilizar el Window Day con Needify o el Window Activated y demás y solamente vamos a utilizar el Window Closing, ¿para qué vamos a tener el resto? Bueno, pues para poder ahorrarnos en código y no tener todo este código que al final lo único que genera es basura visual. 00:44:22
porque daros cuenta que cuando estéis trabajando, bueno, cuando estéis trabajando, cuando estéis haciendo un examen, cuando estéis haciendo cualquier proyecto de esto que estamos haciendo, es muy importante que el código esté medianamente ordenado, que no haya código redundante, que los elementos estén llamados correctamente, ¿por qué? 00:44:45
Porque con eso enseguida cuando os dé un fallo vuestro programa, ya sea porque el usuario os ha puesto una pistola en la cabeza o bien porque tenéis que entregar algo y no os da tiempo, pues con esto os vais a ahorrar muchísimo tiempo porque va a ser muy claro. 00:45:05
Es decir, cuanto más claro sea el código, mejor para todos. Cuando digo para todos, quiero decir que cuando estéis trabajando, seguramente vuestro código no será vuestro código, ya va a pertenecer a un equipo y seguramente vosotros estéis en ese proyecto, a lo mejor vamos a poner tres meses y a los cinco meses aparezca otro chaval que acaba de salir del DAO y llegue y le diga, venga, tienes que mejorar este código. 00:45:20
Pues si no se lo habéis dejado muy claro, le estáis haciendo la puñeta al chaval. Al igual que si cuando vosotros empecéis a trabajar, cuando lleguéis a un proyecto y accedáis a un código, si está hecho de forma poco clara, pues os va a tocar pelearos con entender qué coño quería hacer la persona o no. 00:45:47
Al igual que eso también os recomiendo siempre utilizar muchos comentarios, muchos comentarios, de hecho, bueno esto ya va aparte de esta clase, ya aprovecho deciros que por lo general casi todos los proyectos actuales tienen que pasar unos sistemas de calidad bastante fuertes 00:46:08
Y eso que quiere decir que vuestro código va a tener que estar formateado de una manera, X, que se va a exigir, pero aparte siempre os va a pedir el comentar todas las funcionalidades de una manera. 00:46:31
Al igual que lo vais a tener que comentar, lo vais a tener que documentar en documentos de Word y en manuales de usuario. Es decir, el 60% de vuestro trabajo va a ser que contéis qué está haciendo realmente vuestro programa. 00:46:45
el otro 40 va a ser un 15 pensar cómo se hace un 25 el hacerlo y un 60 al contárselo a o bien a 00:47:03
través de comentarios o bien a través de manuales de usuario que os va a tocar vale pero bueno eso 00:47:16
no tiene nada que ver con la clase de hoy ya os lo digo yo porque se me ha bueno para ahorrar 00:47:23
estábamos diciendo que para ahorrarnos tener que implementar todos los métodos que a lo mejor no 00:47:29
vamos a utilizar hay un hay unas clases que son los adapters vale adaptadores entonces todos los 00:47:35
todos los listeners tienen un tipo windows adapter vale aquí si os fijáis tenemos él 00:47:44
perdona que me quedo sin voz y no tengo mucha por ejemplo para el window listener pues tenemos 00:47:53
el window aparte adapter para el key listener tenemos el key adapter para el mouse listener 00:48:02
el mouse adapter vale es decir esto es de mucha de mucha utilidad aquí vamos a ver un ejemplo 00:48:09
entonces lo que vamos a hacer con el ejemplo que teníamos antes vamos a quedar con el window 00:48:17
closing y vamos a quitar todo esto nos dará unos cuantos casques ves ya nos está ya nos está 00:48:31
diciendo que le faltan que le faltan métodos obligatorios vale vamos a eliminar todos los 00:48:37
que tenemos por aquí que no nos interesan y nos vamos a quedar con el que hemos generado antes 00:48:46
que este sí que hemos dicho que queríamos que nos mostrará la ventanita cuando cerramos etcétera 00:48:53
etcétera entonces para que no nos dé este error y para que simplemente podamos utilizar este vamos 00:48:58
a utilizar el adapter si os fijáis aquí y entonces le damos a window adapter y le metemos la clase 00:49:05
y por qué no nos está cogiendo el window adapter que nos dice que no hemos hecho en la importación 00:49:36
Bueno, si os fijáis, ahora estamos utilizando el mismo Windows Listener, pero en lugar de tener que pintar en nuestro código todos los métodos que se supone que la interfaz nos obliga, 00:49:49
simplemente al darle con su adapter, al utilizar su adapter, nos va a aparecer, o sea vamos a poder simplemente utilizar uno de ellos 00:50:08
en este caso el window closing, vamos a ver si funciona, crucemos los dedos, si le damos aquí, seguro que quiere salir 00:50:19
funciona exactamente igual y sin embargo nos hemos ahorrado unas 30 líneas de código 00:50:30
pues siempre es interesante el poder utilizar un adapter. Igual que el adapter, podríamos utilizar cualquiera de los otros métodos. 00:50:38
Y hasta aquí leeríamos, vamos, sería un poco la teoría aplicada con el tema de las interfaces gráficas. 00:50:50
luego ahora a partir de ahora, ahora me preguntáis si hay alguna duda y demás 00:51:02
pero bueno ahora a partir de ahora los ejercicios 00:51:07
bueno ya sabéis cómo funcionan las interfaces gráficas 00:51:11
entonces vamos a hacer una serie de ejercicios si os parece 00:51:16
y los vamos a ir mezclando ya un poco con esa parte que os gustó tanto 00:51:18
que es la de las estructuras dinámicas 00:51:27
con las listas, los hash maps y todo esto, ¿vale? 00:51:29
Así es que, así es que, bueno, pues vamos hasta aquí 00:51:34
para ver si os parece la clase de teoría. 00:51:40
¿Alguien tiene alguna pregunta, alguna duda con respecto a esto? 00:51:46
¿No? Bueno, yo voy a subir, el otro día subí una versión 00:51:52
de los apuntes, pero estaba sin terminar. 00:51:56
voy a subir esta versión al Moodle y entonces si ahora estos días estáis haciendo los ejercicios 00:51:58
os recomiendo que tengáis estos ejemplos para que podáis ver un poco cómo llevarlos a cabo, ¿vale? 00:52:05
Paro la grabación... 00:52:18
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Raúl López
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
17
Fecha:
11 de marzo de 2025 - 10:42
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
52′ 22″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
199.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid