Saltar navegación

Java Swing GUI 3 - eventos - 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 14 de abril de 2023 por Stefano C.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

voy a grabar esto por lo tanto si habláis me está dando vuestra autorización a que se 00:00:01
grabe vale entonces esto lo hemos repasado lo que hemos hecho ayer vale la ventana pues vamos 00:00:06
a crear otra pequeña ventanita para poder darle un poco de funcionalidad entonces me 00:00:13
creo un nuevo de la clase la llamó mi ventana 2 vale esto extensa frame así es también me copio 00:00:20
una parte aquí para que sustancialmente la parte digamos esta de aquí que es muy parecida a la 00:00:42
que ya hemos hecho anteriormente funciones hola visible vale entonces he hecho mi ventana 2 vale 00:00:55
he hecho un constructor para que pueda crear una pequeña ventana nueva si hay un error de tipo 00:01:12
Entonces si quiero crear 00:01:22
Esta ventana de aquí 00:01:27
En vez de crear en el principal 00:01:29
Mi ventana 00:01:31
Pongo mi ventana 2 00:01:33
Ahí 00:01:35
Ahora estoy creando una ventana 00:01:37
De este otro 00:01:40
Que como no tiene ningún 00:01:41
Elemento dentro pues no hace nada 00:01:43
Vamos a ponerle 00:01:45
Un botón 00:01:49
por ahora empezamos con un botón y vamos a ver qué pasa vale y le damos funcionalidad entonces 00:01:50
creó un jay boston como aquí dentro lo creo es igual al año 00:01:56
que le escribo dentro por ejemplo 00:02:17
Pulsame 00:02:19
Importo 00:02:22
JButton para que pueda utilizarlo 00:02:33
Entonces 00:02:36
Ahora que he hecho 00:02:39
Si lo abro 00:02:41
Nada, porque todavía no lo he añadido al panel 00:02:42
¿Vale? Recuerdo que el 00:02:45
Frame tiene por defecto 00:02:47
Un JPanel 00:02:50
Pero todavía no he creado 00:02:51
Este objeto, pero no lo he añadido 00:02:53
Al panel, por lo tanto 00:02:55
No está por ahí 00:02:56
Lo he añadido 00:02:57
Add 00:02:58
Entonces ahora 00:03:00
Tendré esto 00:03:06
Un botón con escrito 00:03:08
Pulsame al centro 00:03:10
Y es un botón que puedo clickear 00:03:11
Y hace nada 00:03:13
¿Vale? 00:03:14
¿Cómo se hace que 00:03:16
Un elemento como un botón 00:03:19
Haga algo? 00:03:21
¿Vale? 00:03:23
Esto entramos en un mundo que se llama 00:03:23
La programación orientada a eventos 00:03:26
¿Vale? 00:03:28
En la programación orientada a eventos, existen eventos, cosas que pasan, ¿vale? 00:03:29
Una cosa que puede pasar es, por ejemplo, alguien ha hecho clic en un botón, ¿vale? 00:03:36
O alguien ha redimensionado la ventana, o alguien ha hecho clic derecho, o alguien ha pasado por encima de otro elemento. 00:03:42
Esto, tenéis algo parecido en HTML, en JavaScript, ¿vale? 00:03:49
Con onclick, ondoubleclick, y cosas por el estilo, ¿vale? 00:03:55
En Java, lo que se necesita hacer es añadir un listener, un escuchador 00:03:58
Mientras en, no sé cómo lo habéis hecho exactamente en JavaScript o algo del estilo 00:04:04
Pero el onClick, por ejemplo, de HTML, pues existe ya 00:04:10
No tenéis vosotros que añadir un escuchador 00:04:14
Es como si él ya lo escucha 00:04:17
Lo que tenéis que poner a tener es que onClick haz algo 00:04:19
Y él automáticamente lo está escuchando 00:04:22
Y cuando pasa ese evento, lo captura, cuando hay el clic, lo captura y hace lo que les he dicho que tiene que hacer, ¿vale? 00:04:25
Aquí en Java, la idea es que es muy parecido, hay un evento, pero yo tengo que añadir yo, como programador, el escuchador de este evento. 00:04:32
O sea, los eventos los hay, pero si nadie escucha los eventos, si nadie se pone a tratar estos eventos, pues no pasa nada. 00:04:45
Cuando yo hago clic aquí, es como si el evento hacer clic, que el botón ha sido pulsado, existe, ¿vale? 00:04:52
Pero nadie lo está escuchando y por lo tanto se ignora, ¿sí? 00:05:04
Entonces no hace nada. 00:05:09
Pues, ¿cómo añado un listener, un escuchador, que pueda escuchar algún evento? 00:05:11
Primero, ¿a quién los tengo que añadir? 00:05:20
¿Quién es que se quiere dar cuenta 00:05:22
Que ha sido pulsado? 00:05:25
El botón 00:05:29
Entonces hará al botón 00:05:30
Que yo añado un listener 00:05:32
Un escuchador 00:05:34
Y le digo, botón 00:05:35
¿Cómo añado algo? 00:05:37
Con add 00:05:42
¿Qué añado aquí? 00:05:42
¿Os suena algo 00:05:46
De todos estos nombres 00:05:48
Que pueda ser 00:05:50
Interesante? 00:05:52
Esto podría ser 00:05:54
¿Vale? A lo mejor veis que hay varios 00:05:59
Listener, Ancestor Listener 00:06:01
Change Listener, Component Listener 00:06:03
Focus Listener 00:06:05
Cada uno de estos 00:06:07
Escucha algún tipo 00:06:08
De evento 00:06:11
¿Vale? Que ahora veremos 00:06:13
Algunos lo veremos más en el futuro 00:06:15
Por ejemplo el Focus Listener es cuando 00:06:17
El elemento adquiere 00:06:19
El Focus 00:06:21
¿Vale? 00:06:22
¿Sabéis cuando vosotros dais tab 00:06:23
Y pasáis desde un campo a otro 00:06:25
De un formulario? 00:06:28
Cuando cambio a un elemento 00:06:30
Ese elemento tiene el focus 00:06:32
¿Sí? 00:06:34
El changelist posiblemente se basa sobre 00:06:35
Cosas de 00:06:38
Cambio de la ventana 00:06:38
Si la ventana se hace más grande, por ejemplo, se hace un change 00:06:41
Entonces se hará un 00:06:43
Nosotros lo que vamos a utilizar 00:06:46
Es el actual list 00:06:50
¿Vale? Entonces si añado 00:06:51
Un ActionListener 00:06:53
¿Vale? Muy bien 00:06:54
Esto quiere decir que ahora 00:06:56
Estoy añadiendo a este botón 00:06:58
Escuchador de acciones 00:07:03
¿Vale? Fenomenal 00:07:05
Por defecto él me dice un 00:07:07
¿Qué pongo aquí? Lo hemos visto 00:07:08
Si os fijáis 00:07:11
Aquí me dice 00:07:18
Me va a poner un ActionListener 00:07:19
¿Vale? Te añado un ActionListener 00:07:21
Pásame el ActionListener 00:07:24
¿Vale? ¿El ActionListener qué es? 00:07:26
Pues el ActionListener es una clase 00:07:28
En realidad es una interfaz 00:07:29
¿Vale? Entonces yo puedo 00:07:31
Pasarle aquí cualquier clase 00:07:34
Que implemente 00:07:36
La interfaz 00:07:38
ActionListener 00:07:39
¿Sí? Vamos a hacerlo así 00:07:40
Como primer paso 00:07:45
ActionListener 00:07:50
Como primer paso 00:08:04
Vamos a crearla por fuera 00:08:06
¿Vale? Vamos a ver 00:08:08
Ok, me crea una nueva clase 00:08:09
Que es a mi clase 00:08:11
Haz algo 00:08:21
¿Sí? 00:08:23
Mi clase haz algo 00:08:27
Tendrá que implementar 00:08:28
Action list tener 00:08:31
¿Vale? 00:08:34
Importo este señor de aquí 00:08:36
¿Vale? 00:08:37
Y ahora me dice 00:08:39
Oye, mal 00:08:40
¿Vale? 00:08:41
Porque para que implementes este de aquí 00:08:42
Necesitas implementar los métodos de esa interfaz 00:08:45
Si no, esto no me vale 00:08:49
¿Vale? ¿Y qué método tiene esta 00:08:50
Interfaz? ¿Vale? 00:08:52
Add an implemented method 00:08:54
En particular, este 00:08:55
Se ha 00:08:57
Hecho una acción 00:09:00
¿Vale? Cuando yo 00:09:01
Hago una acción, en automático 00:09:04
Java me crea 00:09:06
Un evento action event 00:09:08
Cuando hay un evento 00:09:10
La información sobre quién ha 00:09:11
Hecho este evento, dónde se ha hecho 00:09:14
Por qué se ha hecho, y cosas por el estilo 00:09:16
Se crea, se empaqueta 00:09:17
En un objeto ActionEvent 00:09:20
¿Vale? Este aquí 00:09:22
Y yo 00:09:24
Este ActionEvent se llama 00:09:25
Se pasa como parámetro 00:09:28
A este ActionPerformed 00:09:30
¿Vale? Si tú eres un ActionListener 00:09:32
O sea que para ser un escuchador 00:09:34
Necesitas implementar un método 00:09:36
Que lo que hace es gestionar 00:09:38
Un evento 00:09:40
Cuando ocurra un evento 00:09:42
Tienes que tener este método 00:09:44
Configurado 00:09:46
Para que yo te pase 00:09:48
El evento que ha pasado 00:09:49
En formato Action Event 00:09:50
Y que tú hagas algo con esto 00:09:53
¿Qué queremos que haga 00:09:55
Nuestro botón pulsado? 00:09:59
Claramente que escriba 00:10:10
Me has pulsado 00:10:11
Aquí, si este es un botón 00:10:12
De guardar, pues lo que tendrá que hacer 00:10:17
Es pillar los ficheros, guardarlos en un fichero 00:10:19
O sea, para pillar los datos 00:10:22
Empaquetarlos, guardarlos en un fichero 00:10:24
Y dejarlos allí 00:10:26
Si es el botón Load, tendrá que buscar el fichero desde el que quiere cargar cosas, 00:10:26
pillar los datos y moverlos a la cosa. 00:10:31
Si es el botón Añade Estudiante, tendrá que pillar el nombre, el identificador, 00:10:34
las notas del estudiante, crear un objeto estudiante y guardarlo. 00:10:40
Tendrá que hacer lo que tiene que hacer. 00:10:44
¿Sí? 00:10:46
Cuando nosotros esto no hace nada, pues simplemente le hacemos que escriba las pulsas. 00:10:47
¿Vale? 00:10:53
Ok, fenomenal. 00:10:53
Tengo mi clase 00:10:54
Que hace algo, vale 00:10:56
Que es un ActionListener 00:10:58
Y aquí, si os acordáis 00:11:00
Necesitaba pasarle un ActionListener 00:11:02
Entonces, ¿qué hago? 00:11:05
Haz algo 00:11:11
Gestor 00:11:12
No sé, Handler 00:11:16
Es igual a new, haz algo 00:11:17
Me construyo 00:11:23
Un objeto 00:11:25
De esta clase de aquí 00:11:26
Y se lo paso 00:11:28
Como parámetro 00:11:31
A este parámetro de aquí 00:11:36
Este método quiere 00:11:38
Un objeto de tipo 00:11:39
ActionListener 00:11:42
Y esto es un objeto de tipo ActionListener 00:11:43
Porque implementa ActionListener 00:11:46
Eso es todo lo que sabemos de 00:11:48
Interfaces 00:11:50
Hemos visto que si yo tengo una interfaz puedo crear un objeto 00:11:51
Que 00:11:54
De tipo esa interfaz 00:11:55
A pacto que implemente esa interfaz 00:11:58
Entonces fijaos que esto es 00:12:00
Haz algo 00:12:02
Y haz algo 00:12:03
Es un 00:12:04
Es un action listener 00:12:05
Habría podido hacer así, creo 00:12:09
No tengo mi portal 00:12:10
Le gusta 00:12:17
Porque este señor implementa action listener 00:12:20
Entonces puede ser considerado como action listener 00:12:24
En cualquier sitio 00:12:26
Donde pueda utilizar un action listener 00:12:27
Puede utilizar un objeto 00:12:30
Haz algo 00:12:31
Entonces se lo estoy diciendo aquí 00:12:32
Le estoy diciendo, ay mira botón 00:12:38
Te voy a añadir un escuchador, una parte, un elemento que si hay un evento, él lo puede gestionar porque tiene un método que es ActionPerformed, que tú puedes llamar y pasarle el evento que ha pasado. 00:12:40
Y él hará lo que tiene que hacer 00:13:02
Que es en este caso 00:13:04
Escribirme a expulsar 00:13:06
¿Dudas sobre esto? 00:13:08
Vamos a ver cómo funciona 00:13:12
¿Lo veis? 00:13:13
Cada vez que yo pulso 00:13:19
Él me escribe 00:13:21
Me ha expulsado 00:13:22
Al hacer click 00:13:23
Salta un evento 00:13:31
Este evento se empaqueta 00:13:33
Se pasa 00:13:35
Al botón 00:13:37
o mejor, se llama con este método 00:13:39
el método ActionPerformed 00:13:42
porque se ha ejecutado 00:13:44
una acción 00:13:46
al botón 00:13:47
el botón mira, tengo algún escuchador 00:13:49
tengo alguien que pueda gestionar 00:13:52
esto, pues si, me han añadido 00:13:54
un ActionListener, por lo tanto 00:13:56
de ese ActionListener voy a 00:13:58
llamar la operación ActionPerformed 00:14:00
y le paso el evento 00:14:02
que ha pasado ahora como parámetro 00:14:04
y ejecuto 00:14:05
y entonces ejecutaré este método cada vez que se ejecute una acción sobre este 00:14:08
objeto de aquí ya claro muchas veces 00:14:17
y yo no me quiero crear una nueva 00:14:36
una nueva clase para luego pasarle el parámetro aquí 00:14:42
A lo mejor no quiero crearme una clase por cada uno de ellos 00:14:50
O es que este es ActionListTener 00:14:58
Se enfada porque dice 00:15:18
No lo estás implementando 00:15:24
Pero yo para añadérmelo 00:15:25
Él me añade aquí 00:15:27
El método ActionPerform 00:15:28
Me lo escribo 00:15:30
Y me encanta 00:15:33
Está claro que ahora yo aquí 00:15:37
En vez de crearme 00:15:54
Un objeto de tipo 00:15:57
Haz algo 00:15:59
desde la instancia de hacer algo y pasar será que le pasó aquí 00:16:00
esto recibe un accionario un objeto claro que objeto claro pero ahora si yo 00:16:10
le paso a ver estoy usando esta 00:16:27
lo que me escribe es me ha expulsado que es lo que hace este 00:16:33
Nosotros hemos dicho, y si no quiero usar esta de aquí, ¿qué puedo hacer? 00:16:42
Y hemos dicho, pues he pillado este objeto de aquí y lo he hecho que implementa también ActionListener. 00:16:46
Entonces ahora no quiero yo pasarle un objeto de tipo haz algo. 00:16:52
No quiero hacer esto. 00:16:56
Quiero usar mi ventana 2 como handle. 00:16:59
Como manejador, como listener. 00:17:04
Entonces que le paso aquí 00:17:07
Para que en vez de utilizar 00:17:09
Haz algo 00:17:11
Utilice a mi mismo 00:17:12
Si yo soy un objeto 00:17:14
Me paso a mi mismo 00:17:17
Y como yo soy un action listener 00:17:19
Puedo 00:17:21
Gestionar eventos 00:17:22
Y cuando hay un evento 00:17:25
Me usarán a mi 00:17:26
Para ver si soy un action listener 00:17:28
Y lo soy 00:17:30
Entonces me llamarán este método 00:17:31
En vez del otro 00:17:33
o sea que aquí yo soy 00:17:35
una ventana, soy una 00:17:37
interfaz, pero también escucho 00:17:39
a mis eventos 00:17:41
principal 00:17:42
aquí, yo soy una clase 00:18:04
mi ventana 2 que tiene un main 00:18:09
que entonces arranca, que crea la ventana 00:18:11
porque es también una ventana, porque es un objeto 00:18:14
de ventana, que es también un action listener 00:18:16
porque también es un action listener 00:18:17
nadie me prohíbe 00:18:19
que una clase sola 00:18:22
haga varias funcionalidades 00:18:23
De hecho, cada vez que yo implemento 00:18:26
Una nueva 00:18:28
Interfaz 00:18:28
Es como si estoy dando 00:18:32
Una nueva funcionalidad 00:18:33
O varias nuevas funcionalidades 00:18:35
Varios nuevos métodos 00:18:37
A mi objeto 00:18:38
Y si mi objeto una vez creado 00:18:41
Puede ser ActionListener 00:18:43
Y puede ser Comparable 00:18:45
Y puede ser no se que 00:18:46
Yo lo puedo utilizar 00:18:47
Este objeto, no obstante sea una ventana 00:18:48
Pero no deja de ser un objeto 00:18:51
Lo que deja de ser una clase 00:18:53
Entonces lo puedo utilizar para otras cosas 00:18:54
¿Sí? 00:18:57
Entonces tengo ya dos métodos 00:19:01
Uno es, me creo una clase fuera 00:19:02
Y utilizo allí 00:19:05
Le hago implementar ActionPerformed 00:19:07
Y luego la utilizo 00:19:09
Como handler de esta 00:19:10
De este evento 00:19:12
Utilizo a mi mismo 00:19:14
Como action de este evento 00:19:17
Esto podría tener algunos problemas 00:19:18
Y si tengo seis botones 00:19:20
¿Qué hago? 00:19:21
Porque con este método de aquí 00:19:25
Podría crear 00:19:27
Haz algo 1, haz algo 2, haz algo 3 00:19:29
Haz algo 4 y a este botón 00:19:32
Le pongo haz 1 00:19:34
A este botón le pongo haz algo 2 00:19:35
A este botón le pongo haz algo 3 00:19:37
Y ya cada botón 00:19:40
Hace una cosa distinta 00:19:42
Pero a lo mejor no es tan bonito 00:19:43
Cuando tengo 56 botones 00:19:46
Y tengo que hacer 56 clases distintas 00:19:48
Cada una que haga prácticamente lo mismo 00:19:50
Pero 00:19:52
Si no, no sé cómo hacerlo 00:19:54
No lo sé, depende de cómo está organizada la cosa 00:19:56
Está claro aquí 00:19:59
Que aquí, ActionPerform 00:20:01
De uno solo 00:20:03
En esta cosa de aquí, en esta mi ventana 2 00:20:04
Cuando le digo que implemente 00:20:07
ActionListener 00:20:09
Tengo un solo método ActionPerform 00:20:10
Entonces si esto lo doy a tres botones 00:20:12
Los tres botones ejecutarán 00:20:15
El mismo método 00:20:17
¿Esto quiere decir e implica 00:20:19
Que los tres botones harán lo mismo? 00:20:21
No necesariamente 00:20:24
Porque yo tengo una cosa que se llama if 00:20:29
Y dentro de este método 00:20:31
Le puedo decir, si 00:20:33
El botón que ha causado este evento 00:20:34
Es el botón 1, haz algo 00:20:38
Y si es el botón 2 00:20:40
Haz algo completamente distinto 00:20:41
¿Qué se puede hacer? 00:20:43
Vale, lo repito 00:20:49
Entonces lo que he hecho ahora 00:20:49
Es que 00:20:51
He creado 00:20:53
He utilizado el action event e 00:20:55
¿Vale? Para acceder 00:20:58
A la fuente de quien ha hecho 00:21:00
El evento 00:21:03
Entonces e.getsource 00:21:03
Me devolverá un objeto 00:21:06
Y este objeto es quien 00:21:08
Ha causado este evento 00:21:10
Y estoy comparando si efectivamente 00:21:12
Este objeto que ha causado el evento 00:21:14
Es mi botón B 00:21:16
Si lo es 00:21:17
Escribo que ha sido pulsado 00:21:19
Ese botón en concreto 00:21:22
El contenido del texto de ese botón 00:21:24
Entonces me sale 00:21:27
Este 00:21:29
Y ahora lo que estaba intentando hacer 00:21:29
Es decir, vale, vamos a intentar poner 00:21:32
Dos botones 00:21:34
Y ver que si clico uno me dice que ha pulsado uno 00:21:35
Y si clico otro ha pulsado otro 00:21:39
¿Vale? 00:21:40
Entonces tengo que añadir 00:21:42
Un nuevo botón 00:21:44
JButton 00:21:46
Para ser muy 00:21:51
¿Si? 00:21:53
Este botón de aquí 00:21:58
Le cambio el nombre, ¿vale? 00:21:59
Este es botón 1 00:22:01
Y esto es botón 2 00:22:04
Añado 00:22:06
B2 también 00:22:12
Ahora hay que ver, hay que cambiar el layout 00:22:15
¿Vale? 00:22:19
Porque si ahora 00:22:20
Fijaos que por ahora no he puesto nada de 00:22:21
Action list, nada de eso 00:22:24
Pero si ahora lanzo la interfaz 00:22:26
Se ve solo uno de los dos botones 00:22:28
¿Vale? Porque se ponían como uno encima de otro 00:22:30
Por lo tanto voy a 00:22:32
Aceptar un set 00:22:34
Layout 00:22:35
Y aquí 00:22:37
No me acuerdo como se llama 00:22:41
Nunca, le tengo que poner 00:22:43
New 00:22:47
Grid layout 00:22:49
Hago una grilla con dos posiciones 00:22:51
Una fila, dos posiciones 00:23:00
Por lo tanto ahora 00:23:02
Tengo los dos botones aquí 00:23:03
Vale 00:23:05
Fijaos que si pulso botón 2 00:23:06
No pasa nada, si pulso botón 1 00:23:09
no pasa algo. ¿Por qué? Porque al botón 1 le ha añadido un ActionListener, 00:23:11
mientras al botón 2 no. Por lo tanto, los eventos del botón 2 se pierden de la nada. 00:23:18
¿Cómo le añado al botón 2 un Listener? Por ejemplo, así. 00:23:24
Fijaos que le ha añadido el mismo Listener. 00:23:30
Entonces, tanto que se pulse esto, como que se pulse esto, se va a ejecutar este señor de aquí. 00:23:33
Y siempre se escribirá 00:23:39
Soy mi ventana y han pulsado un botón 00:23:41
Solo que si 00:23:43
Es B 00:23:45
Me escribirá también esto 00:23:48
Si no es B 00:23:50
No me lo escribirá 00:23:52
Pulso 1 00:23:53
Me dice que ha sido pulsado botón 1 00:23:58
Si pulso 2 00:24:00
Me escribe que ha sido pulsado un botón 00:24:02
Pero no me escribe este otro 00:24:04
No me ejecuta esta parte del código 00:24:05
Porque este es falso 00:24:09
Entonces yo puedo hacer 00:24:10
Una cosa así 00:24:13
Y entonces 00:24:32
Si pulso 00:24:43
1 me dice que ha sido pulsado 00:24:45
El botón 1, si pulso 2 me dice 00:24:47
El botón 2 00:24:49
Esto claramente 00:24:50
Es muy sencillo pero la idea es que 00:24:52
Ahora yo puedo hacer con el mismo 00:24:55
ActionPerformed pasando 00:24:57
El mismo, la misma 00:24:59
instancia de ActionListener 00:25:01
sin haber creado un nuevo objeto 00:25:03
porque estoy usando this 00:25:05
no he tenido que crear uno nuevo 00:25:06
pues puedo hacer a los botones 00:25:08
operaciones distintas 00:25:11
simplemente utilizando 00:25:12
la información que me han pasado aquí 00:25:14
¿dudas sobre esto? 00:25:17
vale 00:25:25
y luego está la tercera forma 00:25:25
¿vale? ¿qué es? vale, mas si yo no 00:25:27
quiero que esto sea un 00:25:29
ActionListener 00:25:31
¿vale? y me crea un objeto 00:25:33
Y quiero decir que hace este objeto sin crearme una clase nueva 00:25:34
No creo, pero no creo 00:25:40
¿Cómo puedo hacer? 00:25:41
Es decir, que yo aquí, al crear este objeto, le quiero decir que hace este objeto 00:25:43
Este botón, al ser pulsado 00:25:50
Entonces, puedo hacer esto 00:25:53
New 00:25:55
Action 00:25:56
PleaseTenor 00:25:59
Y esto explota, ¿por qué explota? 00:26:00
Porque es una interfaz 00:26:05
¿Puedo crear objetos interfaz con new? 00:26:10
¿Por qué no puedo crear 00:26:15
Objetos interfaz? 00:26:17
Porque la interfaz es sustancialmente 00:26:20
Un método abstracto 00:26:26
Entonces yo sé que tiene que tener el método 00:26:28
ActionPerformed, pero sé que siendo 00:26:30
Una interfaz, no tiene 00:26:32
Implementado el método ActionPerformed 00:26:35
Ningún problema 00:26:36
Lo implemento 00:26:38
public void 00:26:42
action performed 00:26:47
action event 00:26:52
y aquí 00:26:55
escribo que tiene que hacer 00:27:09
este botón 00:27:11
por ejemplo 00:27:12
soy 00:27:13
más b 00:27:18
punto 00:27:23
get text 00:27:24
más 00:27:27
Y me han pulsado 00:27:32
Fijaos que 00:27:36
Todo esto está dentro de esta paréntesis 00:27:42
Que es este método de aquí 00:27:46
Todo esto 00:27:47
Todo esto 00:27:50
Es un parámetro de un método 00:27:55
¿Qué estoy haciendo como parámetro de este método? 00:27:59
Creando una nueva instancia 00:28:02
De algo que no puedo crear 00:28:05
Porque ActionListener no es una clase 00:28:07
Es una interfaz 00:28:10
Pero yo le digo 00:28:12
Oye mira, tú créame un objeto ActionListener 00:28:15
Y como para crearte un objeto ActionListener 00:28:18
La única cosa que tú necesitas en realidad 00:28:20
Es que te implemente un método 00:28:22
O te implementen los métodos 00:28:23
De esa interfaz 00:28:25
Pues entonces si yo te doy la implementación de esos métodos 00:28:26
No me importa crear una clase concreta 00:28:29
¿Vale? 00:28:32
Estas se llaman clases anónimas 00:28:33
La realidad es que estoy creando una clase 00:28:36
Pero ni siquiera le doy un nombre 00:28:41
Porque lo que me sirve 00:28:43
Es que sea un action listener 00:28:45
Entonces te estoy creando aquí 00:28:47
Directamente que tiene que hacer 00:28:51
Este botón 00:28:53
Entonces tengo estas tres posibilidades 00:28:54
Tengo la posibilidad de crearme 00:28:58
Una clase externa 00:28:59
Que sea la que gestiona estas cosas 00:29:01
Vale, fenomenal 00:29:03
Utilizar la misma clase 00:29:04
Que es la ventana para que gestione 00:29:07
Las pulsadas de los botones de los eventos 00:29:09
Vale, fenomenal 00:29:11
O crearme una clase anónima 00:29:12
Que sirva para este evento concreto 00:29:15
O sea, para la gestión de los eventos 00:29:17
De este elemento concreto 00:29:19
O una combinación de las tres cosas 00:29:20
Nadie me prohíbe 00:29:24
Que esto se lo ponga así 00:29:26
Y esto se lo ponga como dice 00:29:27
Vamos a ver que esto funciona 00:29:29
Cuando yo pulso en el botón 2 00:29:38
Me está llamando esto 00:29:42
Y funciona 00:29:44
Cuando pulso en el botón 1 00:29:46
Soy botón 1 y me han pulsado 00:29:48
Es lo que viene 00:29:50
En esta 00:29:51
Clase anónima que he creado 00:29:55
Y sustancialmente 00:29:58
Autor/es:
stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
15
Fecha:
14 de abril de 2023 - 13:29
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 10″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
252.86 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid