Un evento es el desencadenante de una acción. Para verlo más claro y ver cómo funcionan los eventos vamos a abrir un procesador de texto, por ejemplo, el Word o el LibreOffice Writer.
Nada más abrir el Word nos aparece por defecto que esta activada la pestaña Inicio. Si hacemos clic en la pestaña Correspondencia:
Se ha producido un evento, el evento ha tenido lugar al hacer clic y la acción que ha desencadenado este evento ha sido cambiar de pestaña. Si hacemos clic en uno de los iconos de la pestaña Correspondencia:
Se ha producido el mismo evento al hacer clic con el
ratón, pero el evento desencadenante es otro, se ha desplegado un menú.
En Word no solo se producen eventos haciendo clic con el ratón, se pueden producir eventos utilizando el teclado, por ejemplo, si pulsamos la tecla de función F1
Aparece la ventana de ayuda de Word, el evento se ha
producido porque en este caso hemos pulsado una tecla, el evento que
desencadena es abrir la ventana de Ayuda
de Word.
Así es como funcionan los eventos.
Lo primero al programar un evento es
tener en cuenta los tres factores que se va a desencadenar:
·
¿Qué desencadena la acción? à Objeto Evento
·
¿Quién desencadena la acción? à Objeto Fuente
·
¿Quién recibe la acción? à Objeto Listener
Lo primero es ¿Qué
desencadena la acción? en esta primera pregunta nos referimos al evento,
haciendo clic con el ratón, pulsando una combinación de teclas con el teclado,
cambiando el tamaño de la ventana, etc. Una vez identificado el primer factor
tenemos que identificar quien desencadena la acción, por ejemplo, una vez que
se hace clic con el ratón se despliega un menú, una vez identificado este
factor el tercer factor es quien recibe esta acción.
Volvemos al ejemplo del Word, cuál será el Objeto
Evento para cambiar de pestaña, será el hacer clic con el ratón. Al abrir Word por defecto se abre en la pestaña
Inicio, si hacemos clic en el menú Correspondencia
el objeto Evento que nos hace ir a la pestaña Correspondencia es el ratón, es decir, al hacer clic. El que
desencadena el evento es la ficha Correspondencia,
es el objeto Fuente y quien recibe
la acción es la cinta de opciones.
Una vez teniendo esto claro hay que programarlo, el Objeto Evento se compone de las siguientes clases:
Al hacer clic, al pulsar una tecla, etc., se utiliza
la clase EventObject que descienden el resto de clases que
desencadenan eventos, por ejemplo, ActionEvent y la
clase WindowEvent. Para utilizar ActionEvent tendremos
que utilizar los métodos que pertenecen a esta clase cuando se realicen
acciones con el ratón, doble clic, clic, clic con el botón derecho, etc., esta
clase pertenece al paquete java.awt.event por lo que cuando se
utilice tenemos que importar este paquete. Cuando estemos realizando acciones
de ventana utilizaremos WindowEvent, cuando se cambia el tamaño de
la ventana, se maximiza, etc., y lo mismo, tendremos que utilizar los métodos
de esta clase, pertenece al mismo paquete.
Luego están el Objeto Fuente y el Objeto Listener:
En un objeto Fuente tenemos un
botón JButton que lo que queremos que haga es que cuando se
pulse se cambie el color del fondo del frame. El objeto Listener va
a ser la lámina que es la que cubra de color el fondo, JPanel. El
objeto Fuente tiene que tener un método addActionListener() con
este método le indicamos a que objeto hay que enviarle esta acción. El
objeto Listener tiene la clase JPanel que es
el que recibe la acción tiene que implementar una interfaz, esta interfaz
es ActionListener.
Bien, pues después de la teoría viene la práctica, nos
creamos una nueva clase con el código siguiente:
package event;
import
javax.swing.JFrame;
import
javax.swing.JPanel;
public class PruebaEventos {
public static void main(String[] args) {
MarcoBotones mimarco=new MarcoBotones();
mimarco.setVisible(true);
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoBotones
extends JFrame{
public MarcoBotones()
{
setTitle("Botones
y Eventos");
setBounds(700, 300, 500, 300);
LaminaBotones milamina =new
LaminaBotones();
add(milamina);
}
}
class LaminaBotones
extends JPanel{
}
Es un código similar al que hemos utilizado en el
apartado Introducción a las aplicaciones
Swing. El código te crea una ventana. Vamos a crear un botón y cuando se
pulsé sobre él el fondo de la lámina se va a rellenar de azul. Así que en la
clase LaminaBotones vamos a crear
nuestro primer botón lo hacemos con la clase JButton:
class LaminaBotones
extends JPanel{
JButton
btnAzul = new JButton("Azul");
}
Creamos un constructor donde vamos a añadir el botón
en la lámina:
public LaminaBotones()
{
add(btnAzul);
}
Si probamos la aplicación vemos que hemos creado un
botón que al pulsar de momento no hace nada.
A partir de aquí tenemos que plantearnos los tres
factores que van a tener lugar a la hora de producirse el evento. Por un lado
cual va a ser el evento, el evento va a ser al hacer clic en este botón, el
segundo factor el objeto desencadenante del evento del objeto fuente, el objeto
fuente va a ser el botón, y el tercer factor va a ser el objeto receptor o el
objeto destino del evento, es decir, el objeto listener, como en
este caso queremos que la propia lamina se ponga en color azul pues el objeto
que va a ser oyente de este evento va a ser la propia lámina.
En primer lugar para que nuestro objeto fuente sea
capaz de ejecutar o desencadenar un evento concretamente al hacer clic hay que
utilizar el método AddActionListener. En los parámetros de este
método tendremos que especificar quien va ser el oyente:
btnAzul.addActionListener(this);
This lo que hace es referenciar al objeto donde nos
encontramos, de esta forma le estamos diciendo a nuestro botón Azul que va a
desencadenar un evento al hacer clic y que ese evento lo tiene que recibir el
objeto que hemos puesto como parámetro.
Sin embargo, nos aparece un error porque el oyente
debía implementar una interfaz, la interfaz ActionListener. Por lo
que sería decirle al propio oyente, es decir, a la propia lámina que implemente
la interfaz ActionListener. Al utilizar esta interfaz tenemos que
importar el paquete java.awt.event.ActionListener. Sin embargo, nos
sigue apareciendo un error.
El que implementemos una interfaz implica que estamos
obligados a desarrollar o rescribir los métodos que pertenecen a esta interfaz.
Esta interfaz tiene un método que se llama ActionPerformer, es un
método que marca que hacer cuando se recibe un evento.
A continuación del constructor creamos este método,
este método recibe como parámetro un objeto de tipo evento, va a ser de
tipo Action:
class LaminaBotones
extends JPanel implements ActionListener{
JButton
btnAzul = new JButton("Azul");
public LaminaBotones()
{
add(btnAzul);
btnAzul.addActionListener(this);
}
@Override
public void
actionPerformed(ActionEvent e) {
// TODO
Auto-generated method stub
}
}
Dentro de este método tenemos que indicarle que ponga
la lámina en fondo azul.
public void
actionPerformed(ActionEvent e) {
setBackground(Color.blue);
}
Y con esto ya estaría terminado. Si lo probamos:
Si pulsamos el botón Azul:
Podemos añadir dos botones más que dependiendo del
botón que pulsemos nos rellene el fondo de la ventana de un color o de otro.
Nos creamos los botones:
class LaminaBotones
extends JPanel implements ActionListener{
JButton
btnAzul = new JButton("Azul");
JButton btnRojo
= new JButton("Rojo");
JButton btnAmarillo = new JButton("Amarillo");
Añadimos los botones a la lámina y les añadimos el
método ActionListener:
public LaminaBotones()
{
add(btnAzul);
add(btnRojo);
add(btnAmarillo);
btnAzul.addActionListener(this);
btnRojo.addActionListener(this);
btnAmarillo.addActionListener(this);
}
Si ahora probamos la aplicación:
Cualquier botón que pulsemos nos va a rellenar el
fondo de color azul porque así lo tenemos indicado en el método actionPerformed. Para que al pulsar el
botón Azul, se rellene de fondo de la ventana de color azul, así como al pulsar
el botón Rojo se rellene de color rojo y al pulsar el botón Amarillo se rellene
de color amarillo. Dentro del método actionPerformed
tenemos que utilizar el método getSource()
que lo que hace es capturar el origen del evento.
public void
actionPerformed(ActionEvent e) {
Object
btnPulsado = e.getSource();
if(btnPulsado == btnAzul) {
setBackground(Color.blue);
}else if(btnPulsado == btnRojo) {
setBackground(Color.red);
}else if(btnPulsado == btnAmarillo) {
setBackground(Color.yellow);
}
}
}
Con esto ya tendríamos terminado la aplicación, al
pulsar el botón Rojo el fondo se rellenaría de color rojo, así como el amarillo
y el azul.
4.7 TRABAJANDO CON IMÁGENES << >> 5.2EVENTOS DE VENTANA
No hay comentarios:
Publicar un comentario