Saltar navegación

20250310 GUI_ListenerDesdeWB - 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 17 de marzo de 2025 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, primera cosa, por ejemplo, voy a cerrar yo todo lo que tengo aquí. 00:00:01
Vale, pues venga, ahora sí, se ve y nos escuchamos, ¿no? 00:00:14
Sí, vaya pues despertando, ¿vale? 00:00:18
Que ahora sí que empezamos. 00:00:21
Bueno, pues entonces, primera cosa interesante, 00:00:23
imaginad que vosotros 00:00:26
habéis hecho ya 00:00:29
un frame, pero lo habéis 00:00:33
hecho con el window builder 00:00:35
new other window builder 00:00:36
habéis puesto un frame y ya lo habéis hecho 00:00:39
y ya está, y habéis cerrado 00:00:41
ya ese proyecto, habéis cerrado esa clase 00:00:43
porque habéis hecho otra cosa 00:00:45
y ahora la queréis volver a abrir 00:00:46
por ejemplo, mi caso 00:00:48
este es el proyecto que hicimos el viernes 00:00:50
que solamente tenía la vista, los botones 00:00:52
puestos y ya está 00:00:55
y esta era mi clase 00:00:56
mi frame, no, mi frame era esta 00:00:57
ventana 00:01:00
esta era mi frame, ventana 00:01:00
entonces yo abro ventana para continuarlo 00:01:03
no, no, pero era 00:01:09
el que 00:01:14
suficiente, no necesitamos 00:01:15
a nadie más 00:01:24
nos las entendimos 00:01:24
No, no, no, no, estoy muy a gusto. 00:01:30
Vale, bueno, pues entonces, esta era 00:01:37
la clase que hicimos, de la que hicimos 00:01:39
solamente la vista para 00:01:41
usar el Window Builder y ver un poquito 00:01:43
cómo se usaba. Entonces, yo ya tengo 00:01:46
cerrada, yo ya tengo cerrada 00:01:47
esta clase 00:01:49
y quiero seguir trabajando en ella. 00:01:51
Bueno, pues, le hago 00:01:54
Mario y Daniel, silencio, 00:01:55
le hago doble clic y la abro. 00:01:58
entonces hago doble clic y la abro 00:02:00
y se me ha abierto la pestaña diseño 00:02:03
pero porque yo estaba en el mismo eclipse, pero vosotros a lo mejor 00:02:07
abrís esta clase en otro eclipse, en el eclipse de vuestra casa 00:02:10
o habéis hecho el proyecto en vuestra casa y lo abrís aquí, y esta pestaña no se os va a abrir 00:02:15
entonces decís, y ahora como continúo yo con mi diseño 00:02:20
pues entonces, en lugar de abrirla con doble clic 00:02:23
os acordáis de abrirla con 00:02:28
botón derecho, open with 00:02:30
window builder editor 00:02:32
¿vale? 00:02:35
entonces, primera cosita 00:02:36
si cuando uno abre una clase 00:02:38
que ha hecho con el window builder 00:02:40
con la pestañita de diseño y todo eso 00:02:42
cuando uno la abre, no se le 00:02:44
abre la pestaña diseño 00:02:46
que perfectamente puede ocurrir 00:02:48
que no se le habilite esta pestaña 00:02:51
pues porque está en otro eclipse 00:02:53
o por lo que sea 00:02:55
pues entonces lo que tiene que hacer es 00:02:56
abrirla, hacer 00:02:58
open with y window builder 00:03:00
y entonces ahora ya sí que 00:03:03
se va a abrir, sí o sí, se va a habilitar 00:03:05
sí o sí esa pestaña 00:03:06
bueno 00:03:07
pues entonces 00:03:09
nosotros 00:03:13
hicimos la vista solamente, si abrimos 00:03:15
la pestaña diseño 00:03:17
esto es lo único que hicimos 00:03:18
poner los componentes 00:03:21
introducir nombre, aquí el área de texto para poner 00:03:22
el nombre y aquí el botoncito para borrar, ¿vale? 00:03:25
Entonces, fijaos que aquí a la izquierda aparecen todos los 00:03:28
componentes que habéis metido. 00:03:34
Aparecen todos y aparecen además jerárquicamente si uno está en 00:03:38
algún contenedor, pues, aparece colgando ese contenedor. 00:03:42
Entonces, ¿por qué es importante esta ventanita? 00:03:46
Por ejemplo, cuando nosotros añadimos un componente, 00:03:49
lo añadimos a un panel. 00:03:52
Entonces, para asegurarnos de que lo que está aquí seleccionado es el panel, 00:03:53
lo mejor es marcarlo aquí. 00:03:57
¿Vale? 00:03:59
Entonces, puede ser que tengamos varios paneles, 00:04:01
como ahora podemos hacer un ejercicio cualquiera, varios paneles. 00:04:03
Entonces, ¿cómo sé yo qué panel es el que está aquí activo? 00:04:06
Pues lo marcáis aquí. 00:04:10
Ah, vale, ya está. 00:04:11
Ese es el panel que estoy trabajando. 00:04:13
Y ahora ya añadís cosas y lo que sea. 00:04:14
Aquí en este caso tenemos el frame, 00:04:17
un panel colgando del frame, 00:04:20
Y cuatro componentes. 00:04:23
¿Vale? No tenemos más. 00:04:25
En texto introduzca nombre, 00:04:28
el cambio de color y el botón de borrar. 00:04:30
Esto es muy bueno. 00:04:31
Ay, si hubieras venido el viernes. 00:04:34
¿Con Andrea? 00:04:36
Si hubieras venido el viernes con tus amigas. 00:04:38
Claro, una hora y media 00:04:40
podría ponernos. 00:04:41
Por ejemplo. 00:04:42
Pero lo que te habría compensado, ¿eh? 00:04:45
Y un recreo. 00:04:46
Lo que habrías disfrutado con ellas. 00:04:48
Bueno, eso. 00:04:50
Vale, pues a ver 00:04:53
Cuando vosotros seleccionáis 00:04:58
Un componente cualquiera 00:05:00
Un componente 00:05:02
Aparte de que veis que ese componente se queda seleccionado aquí 00:05:03
Aquí en la 00:05:07
Ventanita hasta de abajo 00:05:08
Que pone propiedades 00:05:11
Pues aparecen todas las propiedades 00:05:12
De ese componente 00:05:15
O de ese panel o de ese elemento en general 00:05:15
¿Vale? 00:05:18
Por ejemplo, selecciono el frame 00:05:20
pues me aparece a qué clase 00:05:22
pertenece y las propiedades 00:05:23
que tenga, si está habilitado 00:05:25
no está habilitado, cuál es su color 00:05:27
de fondo, de todo 00:05:29
el panel 00:05:31
seleccione el panel, pues su nombre, ¿cuál es? 00:05:33
pues panel principal, ese es el nombre de la variable 00:05:35
que yo le quiero 00:05:38
cambiar el nombre de la variable porque no me gusta 00:05:40
el nombre panel principal 00:05:41
pues le cambio el nombre de la variable 00:05:42
mi panel 00:05:46
ala, le cambio 00:05:47
el nombre de la variable, si ahora me voy a 00:05:49
fuente otra vez a la pestaña de fuente 00:05:51
veo que efectivamente 00:05:53
ha cambiado, ahora se llama 00:05:55
mi panel 00:05:57
bueno pues 00:05:58
entonces desde esta ventanita de propiedades 00:06:01
yo puedo cambiar muchas cosas 00:06:03
de cada uno de los elementos de la interfaz 00:06:05
repito, uno de ellos 00:06:07
el primero que aparece es el nombre de la variable 00:06:09
el nombre que tiene 00:06:11
ese componente en el código 00:06:13
porque el window builder cuando tú le pones 00:06:14
cosas te pone nombres muy feos por defecto 00:06:17
Jbutton 1, Jbutton no sé qué 00:06:20
Pues hombre, mejor vamos aquí y lo cambiamos 00:06:22
Vale, entonces lo de los colorcitos 00:06:24
Pues es que aquí abajo en propiedades 00:06:28
Tienes todo lo que puedes cambiar de un componente 00:06:30
Entonces aquí en esta área, por ejemplo 00:06:31
El panel, vamos a cambiarle 00:06:33
El background 00:06:36
Pues le ponemos 00:06:38
Aquí, venga 00:06:40
¿Qué color quieres para el background? 00:06:41
Pues le quiero 00:06:44
Rosy 00:06:45
Aceptar 00:06:46
vale, ya está rosa 00:06:49
entonces, ahora efectivamente 00:06:56
si nos vamos a fuente 00:06:58
se habrá generado un código 00:06:59
con el método cambiar el color, este 00:07:01
en lugar de hacerlo yo a mano con el set background 00:07:03
pues lo he hecho desde el builder 00:07:08
¿vale? el builder es una 00:07:10
manera cómoda de generar 00:07:12
el código automáticamente, pero obviamente 00:07:14
no es necesario, podríamos haber llamado 00:07:15
a este método y listo 00:07:17
creado un objeto color con las coordenadas 00:07:19
de color red, amarillo, 00:07:22
red, blue y green, que sean. 00:07:24
Y ya está. 00:07:26
¿Vale? 00:07:28
Bueno, pues ya está. 00:07:30
Uno aquí va poniendo componentes, 00:07:32
va explorando en las propiedades 00:07:35
lo que quiere cambiar de ellos 00:07:36
y ya construye la vista que le da la gana. 00:07:38
Queremos hacer un preview de la vista 00:07:40
por este botoncito. 00:07:41
¡Hala! Pues sí, una vista muy bonita. 00:07:43
Vale. Entonces, 00:07:46
comportamiento 00:07:48
de esta interfaz. 00:07:49
pues nosotros ahora ya podríamos pasar del window builder 00:07:50
y ya está, e irnos aquí a la pestaña 00:07:53
de fuente y hacer 00:07:56
nuestra clase interna 00:07:57
con el 00:07:59
listener, asociarlo 00:08:01
componente que fuera y ya está 00:08:04
lo único que hemos hecho con el builder es 00:08:07
todo esto, que es poner los 00:08:09
componentes, darles el tamaño y lo que fuera 00:08:11
vale 00:08:13
bueno 00:08:14
pero el builder 00:08:17
también nos permite 00:08:19
cómodamente 00:08:21
crear los listeners. 00:08:23
¿Verdad? 00:08:26
Venga, despierta, date un chute del pegamento 00:08:27
y va arriba. 00:08:28
Despierta. 00:08:32
Bueno, pues venga, por ejemplo, 00:08:35
vamos a 00:08:37
darle comportamiento a este 00:08:38
ejemplo. 00:08:40
Aquí era 00:08:42
el text field. 00:08:43
El text field queríamos 00:08:46
que cuando diéramos al enter 00:08:48
se contara la cantidad de caracteres 00:08:50
que tiene el texto, etc. 00:08:53
Vale, pues 00:08:55
ese es el evento por defecto 00:08:57
del text field. Pues ahora 00:08:59
seleccionamos el text field 00:09:01
botón derecho 00:09:02
en el botón derecho vemos que 00:09:04
nos aparece varias cosas 00:09:07
una de ellas 00:09:09
de lo que nos aparece en el contextual del botón 00:09:10
derecho es, añádeme un manejador de eventos 00:09:13
justo lo que queremos, un manejador 00:09:15
para el evento del text field, darle a lente 00:09:17
añade un manejador de eventos 00:09:19
vale, ¿y qué tipo de evento 00:09:21
es el tuyo? ¿es por defecto? 00:09:23
pues si es el evento por defecto 00:09:26
este, el Action Performer 00:09:27
que ya sabemos que es por defecto 00:09:29
pero hay más eventos aparte del por defecto 00:09:30
pues hacer 00:09:33
clic en el ratón dentro, que el ratón 00:09:35
entre, que salga, mover 00:09:37
la ruedita cuando estás tú ahí dentro 00:09:39
puedes añadir 00:09:41
muchos al mismo componente, nosotros queremos el 00:09:43
por defecto que es hacer clic, pues le decimos 00:09:45
quiero este, el Action Performer 00:09:47
y él se te va el código 00:09:49
para que tú pongas 00:09:51
el código de una relación performa 00:09:53
y ya está, te ha creado la clase 00:09:55
sola, diréis 00:09:57
que fue amarrada de crearme la clase 00:09:58
claro, porque esta ya es 00:10:01
rizar 00:10:03
el rizo que nos faltaba 00:10:05
esto es una clase anónima 00:10:06
a ver, nosotros 00:10:09
¿qué le pasábamos a la de Action Listener 00:10:13
del TextFeed? 00:10:15
a la 00:10:16
sí, sí, sí 00:10:17
a lo que íbamos 00:10:20
nosotros 00:10:23
a las clases anónimas 00:10:23
a las clases anónimas 00:10:27
a ver, nosotros 00:10:28
¿qué le añadíamos a la de ActionListener 00:10:30
de un componente? 00:10:33
un objeto de una clase 00:10:34
de ActionListener, entonces para eso 00:10:36
nos hacíamos una clase que implementaba 00:10:38
ActionListener 00:10:40
con el ActionPerformer dentro 00:10:41
es decir, nos hacíamos esto 00:10:43
Podemos hacerla rápido 00:10:45
Mi listener 00:10:47
Que implement 00:10:51
Action 00:10:52
Listener 00:10:55
Ay, que estrés 00:10:56
Yo quiero darle a 00:11:02
A ver, ¿dónde estás? Ahí 00:11:03
Y ahora 00:11:05
Dentro del action listener 00:11:08
Poníamos 00:11:09
Poníamos el método 00:11:10
Y aquí ya hacíamos lo que 00:11:17
Vale 00:11:22
¿Verdad? 00:11:23
¿Por qué está mi portátil tan tonto? 00:11:26
Ah, porque me lo ha cambiado 00:11:43
Interface, claro 00:11:45
¿Por qué no puedo escribir? 00:11:46
Ah, porque estoy en la clase 00:11:49
Ay, de verdad 00:11:50
Vale, pues entonces 00:11:51
Hacíamos una clase aparte 00:11:55
¿Interna o aparte? Vale. 00:11:56
Y ahora ya instanciábamos aquí 00:11:58
instanciábamos aquí 00:12:00
un nuevo objeto 00:12:02
¿verdad? Un new 00:12:03
¿verdad? 00:12:06
Que esta era nuestra manera de trabajar 00:12:12
era esta, ¿no? 00:12:14
Vale. 00:12:18
Inicialmente nuestra clase estaba fuera. 00:12:19
Dimos el salto por comodidad 00:12:22
para no tener multiplicidad de clases 00:12:23
de hacerla interna. Ahora ya solamente 00:12:25
teníamos un fichero, dos clases dentro. 00:12:27
Vale, dimos el siguiente salto 00:12:29
Para evitar multiplicidad de ficheros 00:12:42
Un solo fichero con las dos clases 00:12:43
Pues el siguiente salto es 00:12:44
Como esta clase 00:12:47
Solo se usa 00:12:49
Para instanciar un único objeto 00:12:50
Que va a ir aquí dentro 00:12:53
Pues no me hace 00:12:54
¿Para qué crear una clase ahí 00:12:57
Que esté ahí muerta de risa 00:12:58
No, se puede hacer una cosa que es clase anónima 00:13:00
Una clase anónima es una clase 00:13:03
Que se declara 00:13:05
En el momento de crear un objeto 00:13:07
Vale 00:13:09
Que es una clase anónima 00:13:11
Justo 00:13:15
Que buena memoria 00:13:18
Clase 00:13:19
Que se declara 00:13:24
en el momento de instanciar 00:13:32
un objeto de la misma. 00:13:34
Y esa clase, 00:13:38
lo que es la declaración, 00:13:40
desaparece. 00:13:41
Se ha instanciado el objeto 00:13:42
de esa clase 00:13:43
y de esa clase 00:13:43
no se pueden instanciar 00:13:45
más objetos. 00:13:46
Si quieres instanciar 00:13:47
otro objeto, 00:13:48
tendrías que volver a declararlo 00:13:48
en el momento de instanciarlo. 00:13:49
Eso es una clase anónima. 00:13:50
Vale. 00:13:52
Pues mira, 00:13:53
es justo lo que nos vendría bien aquí. 00:13:53
Sí, justo. 00:13:56
Entonces, 00:13:57
yo solamente necesito 00:13:58
un objeto de este liceo. 00:13:59
Me solicito un objeto. 00:14:01
Pues, ¿para qué voy a declarar la clase ahí? 00:14:02
Aunque sea interna. 00:14:04
Para tener esto aquí molestando fuera todo el rato. 00:14:05
No la vas a poder usar más veces. 00:14:09
¿Vale? 00:14:11
¿Para qué la voy a tener aquí fuera molestando? 00:14:11
Bueno, si le... 00:14:17
A ver, podías, pero normalmente no es lo habitual. 00:14:18
Pero tú puedes... 00:14:21
Sí, pero tú puedes esta misma clase 00:14:24
instanciar varios objetos 00:14:26
y asociárselo a componentes distintos. 00:14:28
si quieres que diferentes componentes se escuchen con la misma 00:14:30
bueno, hacen lo mismo 00:14:32
o no, si tú tienes un if, el save dentro 00:14:34
en función de cuál fue el origen, ¿no? 00:14:36
claro 00:14:39
entonces, en ese caso 00:14:40
¿vale? pero normalmente no suele ser el modelo 00:14:42
de diseño que se usa, hacer una clase 00:14:44
asociada a diferentes componentes 00:14:47
y que dentro de la clase distingas 00:14:48
en función, no suele ser el modelo de diseño que se usa 00:14:50
sino para mi componente 00:14:52
un objeto listener de una clase suya 00:14:54
para él, entonces como esa clase solo vale 00:14:56
para él y solo me interesa a mí 00:14:58
esa clase porque voy a instanciar 00:15:00
el objeto una única vez, no voy a instanciarlo más 00:15:02
¿para qué la voy a dejar aquí fuera molestando? 00:15:04
creando 00:15:08
tentaciones al resto del mundo 00:15:08
que instancie eso, que no lo quiero que nadie más 00:15:10
lo instancie, ¿para qué? lo mejor 00:15:12
para evitar una tentación 00:15:14
es que esta 00:15:15
clase directamente no exista 00:15:18
y evito la tentación de crearla fuera de su lugar 00:15:20
bueno, pues esa clase no existe 00:15:23
entonces puedo optar 00:15:24
por la clase anónima, que es 00:15:26
aquí, que es cuando tengo que instanciar el objeto 00:15:28
aquí voy a la vez a declarar 00:15:30
la clase, es una clase anónima 00:15:32
¿y cómo se hace? pues como te lo ha hecho 00:15:34
el builder, esa clase 00:15:36
¿vale? implementará una interfaz 00:15:38
pues tú haces esto 00:15:41
venga, venga, que ya casi estoy 00:15:42
¿no? 00:15:50
¿qué? 00:15:53
fallaste, ¿cómo que fallé? 00:15:54
¿ya no me va a ir más para atrás? 00:15:56
sí, esto, vale 00:15:58
entonces tú dices new 00:16:00
¿new qué? new un objeto 00:16:02
de una clase que implemente 00:16:04
acción listener. 00:16:06
Esto porque es el constructor. 00:16:08
Hazme un objeto, no es que crees una acción 00:16:10
listener, creas un objeto 00:16:12
de una clase que implemente acción listener 00:16:14
y su implementación interna 00:16:16
pues que sea esto. 00:16:18
Porque, si entendéis. 00:16:22
O sea, 00:16:27
aquí es como si estuviéramos declarando la clase 00:16:28
una clase que implemente 00:16:30
acción listener, que tenga este método 00:16:32
dentro, que le ponemos el código que sea 00:16:34
y en el momento de declararla 00:16:36
la instanciamos 00:16:38
claro, entonces yo 00:16:39
aquí ya pongo el código 00:16:47
al que quiero que se responda 00:16:49
cuando salte el evento 00:16:52
de este componente 00:16:53
claro 00:16:54
porque estoy instanciando el objeto 00:16:57
este paréntesis se abre y se cierra aquí 00:16:59
e instancio porque hay un new 00:17:01
con paréntesis 00:17:03
aquí no pongo el nombre de la clase 00:17:05
porque por eso es anónima, no tiene nombre 00:17:08
aquí pongo el nombre de la interfaz 00:17:09
de la que hereda 00:17:12
y aquí el código 00:17:12
que es obligatorio que implementes 00:17:16
a clase, entonces le estoy dando el código 00:17:18
ahí, le estoy dando el cuerpo ahí, entonces la estoy declarando 00:17:20
a la vez que la instancia 00:17:22
claro, pero es como que estás 00:17:24
sé que es un objeto que implementa 00:17:25
la interfaz, pero tú lo declaras 00:17:28
como que es para la interfaz 00:17:30
sí, pero estás creando 00:17:31
una versión de esta interfaz con este código 00:17:34
es lo que significa 00:17:36
créame una versión de esta interfaz 00:17:37
pero con este código de aquí 00:17:40
eso que viene a ser 00:17:42
créame una implementación concreta de esa interfaz 00:17:43
viene a ser eso 00:17:46
lo que pasa es que en lugar de hacerlo con 00:17:47
créame una clase que la implemente 00:17:49
ahora créame un objeto de esa clase 00:17:51
en lugar de hacerlo así le dices 00:17:53
créame una instancia de algo que implemente 00:17:54
esta interfaz 00:17:58
y esa instancia que tenga este código dentro 00:17:59
Si tú quieres hacer una versión 00:18:02
Bueno, es que 00:18:14
El mismo compilador te lo va a decir 00:18:18
Claro, tú dices 00:18:20
Créame una versión de esta clase 00:18:22
Entonces si esta clase 00:18:24
Es abstracta o anónima 00:18:26
O interfaz, te va a decir 00:18:28
Oye, si tú quieres que yo te instancie un objeto que implemente esto, 00:18:30
pues me vas a tener que dar el código. 00:18:36
¿Vale? 00:18:40
Entonces, esto es una especie, pues eso, de, tú le puedes decir, 00:18:42
por favor, quiero un objeto de este tipo, un objeto, 00:18:50
acción listener, pero quiero que sea un objeto. 00:18:55
Entonces, tiene que implementar el código de la interfaz. 00:18:57
Quiere un objeto de este tipo 00:19:00
Y ese objeto en particular 00:19:02
Que su implementación 00:19:03
Del método vacío de ActionListener 00:19:05
Que es el obligatorio que tengo que poner 00:19:08
Que su implementación sea esta 00:19:09
Que no lo sabía 00:19:10
Pero a ver 00:19:26
A ver 00:19:27
Que no 00:19:31
A ver, no creo 00:19:34
A ver, los hombres fingen con mucha facilidad 00:19:36
Pero vamos, no lo creo capaz 00:19:38
de fingir tan bien. 00:19:40
Vale, pues a ver. 00:19:46
Para entenderlo. 00:19:48
Esto es que tampoco tiene tanto que entender. 00:19:50
Es volver a decir lo que significa 00:19:52
y luego, ¿qué hace falta 00:19:54
para que uno entienda algo? 00:19:56
Que ya se ponga sus neuronas en funcionamiento 00:19:57
y él solo en su intimidad, 00:20:00
exclusivamente el solito, 00:20:02
cuando ya nadie le esté hablando, 00:20:04
se ponga y lo mire 00:20:06
y lo procese y se lo aprenda. 00:20:07
no se entienden las cosas que no están 00:20:10
memorizadas 00:20:13
en general, ya sé que hay matices 00:20:14
ya sé que hay matices 00:20:16
pero tú para procesar datos 00:20:17
tienes que tenerlos, eso está claro 00:20:20
pues eso es a lo que me refiero 00:20:22
para tú procesar una información 00:20:25
tienes que tener la información 00:20:26
la información tiene que estar en la cabeza, no tiene que estar ahí 00:20:27
entonces 00:20:30
vale, pues aquí 00:20:31
repetimos ya por última vez 00:20:34
aquí está claro 00:20:37
que al addActionListener, si lo habéis memorizado 00:20:38
del otro día, porque no lo habéis 00:20:41
memorizado, es donde falla 00:20:42
en que lo del 00:20:44
día anterior no esté memorizado 00:20:46
a la vez que entendido, pero ya he memorizado. 00:20:48
Pues ya he memorizado, recordaréis que 00:20:50
al addActionListener hay que pasarle un 00:20:52
objeto, sí o sí, un objeto. 00:20:54
Que es un objeto 00:20:57
de tipo actionListener, 00:20:58
pero de un actionListener particular. 00:21:00
Del actionListener que implemente 00:21:02
a través de este 00:21:05
método el código que tú quieres que ocurra. 00:21:06
eso está claro, vale 00:21:08
pues en lugar de hacer la clase 00:21:11
aparte e instanciar el 00:21:13
objeto, podemos hacerlo como 00:21:15
clase anónima, que es, no voy a hacer la clase 00:21:17
aparte, porque solo voy a usar una vez 00:21:19
entonces de esta manera 00:21:20
lo podemos hacer, new y 00:21:22
paréntesis, porque es una instancia 00:21:25
luego una instancia siempre es con 00:21:27
new y paréntesis, vale 00:21:29
¿qué le decimos aquí? en lugar del 00:21:31
nombre de la clase que yo voy a instanciar 00:21:33
le decimos de que 00:21:35
qué interfaz implementa 00:21:36
sería como decirle 00:21:39
este objeto es de este tipo 00:21:40
es un listener, pero es un ejemplo 00:21:43
concreto de listener 00:21:45
sí 00:21:46
sí 00:21:47
es de este tipo, este objeto va a ser de este tipo 00:21:49
entonces como este tipo tiene 00:21:55
métodos vacíos 00:21:56
pues tienes que decir, vale, muy bien, yo te instancio 00:21:57
un objeto de este tipo, action listener 00:22:00
pero tienes que decirme 00:22:03
que quieres que haga en los métodos vacíos 00:22:04
si no me dices que hace en los métodos vacíos 00:22:06
no te lo puedo implementar 00:22:08
¿vale? 00:22:09
entonces ¿cómo se lo dices? pues poniendo entre llaves 00:22:11
todo el código 00:22:14
de la clase 00:22:16
que serían los métodos vacíos, que aquí solo hay uno 00:22:17
bueno, pues aquí 00:22:20
¿qué queremos que haga? 00:22:24
pues eso es lo que, así nos lo hace el builder 00:22:26
¿vale? esto es lo que nos ha hecho 00:22:28
cuando le hemos dicho 00:22:30
añade un manejador de eventos 00:22:31
aquí ya me lo tiene puesto, ya me lo ha añadido, el 56 00:22:33
a Diven Handler cuando le hemos dicho 00:22:36
que añade un manejador de eventos 00:22:39
pues él me ha creado eso 00:22:40
y ya está, y ahora nosotros lo único que tenemos que hacer 00:22:42
es meter aquí eso y así, eso ya el builder 00:22:46
obviamente no va a adivinar por nosotros 00:22:48
qué queremos que pase cuando 00:22:50
se dé enter al botón 00:22:52
eso no lo puede adivinar 00:22:53
ahora ya nosotros algo tendremos que hacer 00:22:55
que es, qué queremos que pase en este ejercicio 00:22:58
vete al contenido 00:23:00
del text field, el que tenga 00:23:02
en ese momento 00:23:04
saca la cadena que tenga dentro 00:23:05
cuenta los caracteres 00:23:08
y ponme ese numerito 00:23:10
en la etiqueta pensada al efecto 00:23:12
vale, vamos parte por parte 00:23:14
sacamos 00:23:16
el contenido 00:23:19
del text field 00:23:24
el text field 00:23:27
¿cómo se llama? nombre 00:23:30
pues ¿cómo saco yo el contenido de un text field? 00:23:31
pues voy a averiguar cómo funciona el text field 00:23:34
averiguo y digo, anda, tiene un método que se llama 00:23:36
que es casi seguro 00:23:38
que ese método es para sacar el 00:23:40
string que tenga escrito dentro. 00:23:42
String 00:23:49
ala. Bueno, con 00:23:49
esta línea ya he sacado el contenido 00:23:54
que tiene ese text field. 00:23:56
Ahora, ¿qué necesitamos? 00:23:58
Contar los caracteres que tiene. Bueno, 00:24:02
contar los caracteres que tiene 00:24:04
como es un string, es tan fácil como 00:24:05
llamar a Lenz. Pues 00:24:08
venga. 00:24:10
ala, estos son los caracteres que tiene, número de caracteres, ahora, ¿qué tengo que hacer con este número de caracteres?, ponerlo en la etiqueta que estaba habilitada para el resultado, la etiqueta que estaba habilitada para el resultado, era resultado, se llamaba resultado, esa de ahí arriba, pues venga, en la etiqueta, resultado, punto, sectest, cont, 00:24:12
pero claro, setTest necesita que le pases 00:24:40
una cadena, un string para poner el texto 00:24:45
en la etiqueta 00:24:47
cont es un entero 00:24:48
pero bueno, convertir un entero a la cadena que representa 00:24:50
pues ya sabemos 00:24:53
que esta es la forma más cómoda y fácil de hacerlo 00:24:55
y ya está 00:24:56
esta acción performe de hecho 00:24:58
en la etiqueta 00:25:00
y ya está 00:25:15
y ahora ya 00:25:17
pues ejecutamos esto 00:25:20
cuando pongamos aquí el nombrecito que sea 00:25:21
Enter, 14 00:25:24
Ahí está 00:25:26
Es que hay mucho colorino 00:25:30
A ver, vamos, no pasa nada 00:25:32
Vamos a ponerle la etiqueta 00:25:34
¿Dónde está la etiqueta? 00:25:35
La etiqueta resultado es esta 00:25:37
Vamos a ponerle 00:25:39
La etiqueta resultado 00:25:41
Vamos a volver a ejecutarlo 00:25:43
¿Ahora lo ves? 00:25:52
Pero no ves, hay un 11 gigante 00:25:59
o sea que no gusta 00:26:00
el rosa 00:26:05
pues venga 00:26:06
vamos a quitarlo 00:26:10
ah no porque azul 00:26:11
es el área de texto 00:26:19
venga con el amarillito 00:26:20
lo vais a ver muy bien 00:26:23
ala este es mi nombrecito 00:26:25
que tiene nueve caracteres 00:26:34
venga 00:26:35
vale 00:26:42
que haríamos 00:26:46
si queremos que el resultado 00:26:48
salga también 00:26:50
cuando el ratón 00:26:51
se nos escapa y entra 00:26:54
en el área de texto. 00:26:56
Pues ese evento no es el evento por defecto, 00:26:58
con lo cual no lo podríamos pillar con el ActionPerformer. 00:27:00
Pues venga, ¿con qué 00:27:03
vamos a pillar ese evento sobre el área 00:27:04
de texto? A DivenHall, vamos a añadirle 00:27:06
otro. Como es de ratón, 00:27:08
pues vámonos a mouse. Pues cuando 00:27:10
el ratón entre. 00:27:12
Pues venga, cuando el ratón 00:27:15
entre, y como veis, ¿qué me ha añadido 00:27:16
en el área de texto? Me ha añadido ahora un mouse 00:27:18
listener. 00:27:20
Me ha añadido un mouse listener 00:27:22
que hereda 00:27:24
me dice instancia un objeto 00:27:26
que herede de mouse adapter 00:27:28
y hazme aquí el código que quieras 00:27:29
cuando el ratón entre 00:27:32
el área de texto 00:27:33
pues el mismo 00:27:35
el mismo 00:27:36
poner la cantidad de caracteres 00:27:37
ahora el área de texto 00:27:42
tiene dos eventos añadidos 00:27:48
entonces si ponemos aquí un 00:27:50
este 00:27:52
pues no hace falta que des al enter 00:27:53
en cuanto pasas 00:27:57
por aquí, pues te va cambiando el número de caracteres. El botón borrar, para borrar 00:27:59
el texto. Ahora mismo no hace nada. Pues vamos a añadirle un evento a este botoncito. Es 00:28:09
el hacer clic. ¿Queremos que el botón se accione cuando hacemos clic? Sí. ¿Ese es 00:28:19
elemento por defecto? Sí. Pues 00:28:23
a la acción perform 00:28:25
acción perform. Vale. 00:28:26
Pues ya está. 00:28:34
Ya añade una acción listener al botón 00:28:35
limpiar. Le añade una acción listener 00:28:37
un objeto de tipo acción listener con 00:28:39
este código. ¿Qué queremos? 00:28:41
Pues queremos que en el área de texto que se llama 00:28:43
nombre ponga el texto 00:28:45
vacío. Porque eso es lo que 00:28:47
significará limpiar. Poner texto 00:28:49
vacío en el área de texto. 00:28:51
Pues ahora ya nos funcionará el botón. 00:28:53
Sí. 00:28:57
Patapín. 00:28:59
Ya le doy a borrar. 00:29:02
Lo ideal sería que pusiera la etiqueta 0 también. 00:29:04
Se añade el código aquí dentro. 00:29:10
Lo que haga falta. 00:29:12
Set test 0. 00:29:19
Y así nos pone a 0 también la etiqueta. 00:29:23
Cuando le damos a borrar. 00:29:27
Tiene 10 borrar. 00:29:31
Pues nada, lo limpia y lo pone a 0. 00:29:32
En fin. 00:29:35
Vale, pues primero. 00:29:36
practicamos o practicáis con unos ejercicios sencillos 00:29:42
a ver si conseguimos que Cristian 00:29:45
se despierte 00:29:46
y cuando Cristian se haya despertado 00:29:47
después de los ejercicios sencillos 00:29:49
hacemos aplicaciones más grandes para poder ya 00:29:51
si, hoy ha sido mal día para ti 00:29:53
cachis 00:30:00
bueno 00:30:01
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:
10
Fecha:
17 de marzo de 2025 - 10:19
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 08″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
136.56 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid