Eventos

La gestión de eventos 10 - 1
CAPITULO 10
La gestión de eventos
Objetivos:
• Explicar la manera como Java maneja los eventos
• Identificar los diferentes tipos de eventos y sus clase manejadoras.
• Desarrollar programas que manejen diversos tipos de eventos.
• Utilizar algunos componentes Swing para manejo de sus eventos
Presentación
La mayoría de programas actuales se relacionan con los usuarios a través de lo
que se denomina como Interfaz Gráfica de Usuario (Graphical User Interface –
GUI por su sigla en Inglés), la cual se puede componer de ventanas, botones,
menús, barras de desplazamiento, areas de texto, íconos e imágenes, y otros
componentes gráficos visualizados en la pantalla, y que fundamentalmente
intermedian entre el ususario y el sistema (hardware y software), para llevar a
cabo procesos de interacción de entrada y salida de información. Se entiende
por componente gráfico un objeto que tiene una representación gráfica
deplegable en la pantalla y que dentro de sus métodos se encuentra la
posibilidad de interactuar con el usuario (que puede ser otro objeto).
Como ya se ha indicado antes, los programas tipo applet se basan en eventos,

los cuales en su mayoría tienen que ver interacciones del usuario. Una
interacción del usuario se pasa al applet y se trata de acuerdo al método
encargado de manejar el tipo de evento determinado, generado por el usuario;
La gestión de eventos : Presentación 10 - 2
por ejemplo, minimizar o restaurar una ventana, presionar un objeto botón

(JButton) en la ventana del applet, presionar el raton, presionar una tecla en el
teclado y otros, generan eventos. El éxito del desarrollo creativo de una
aplicación o applet se fundamenta en el manejo de eventos.
El paquete java.awt y java.awt.event contienen las clases e interfaces

para escribir programas que utilizan interfaz gráfica (GUI).
Un objeto del tipo JTextField, por ejemplo, representa un componente de

texto que al darse enter en el campo de texto por parte del usuario, se genera un
evento que activa la realización de una accion determinada, por ejemplo borrar
el contenido del texto del objeto JTextField.
El manejo de eventos involucra, por tanto, métodos que se llaman de manera

automática cada vez que el usuario realiza un evento o acción sobre un
componente determinado. Se puede afirmar en forma general que, un evento es
un cambio de estado de un objeto, por tanto se generan eventos de manera
interna entre objetos. Aquí se tratará de eventos generados en la interaccion
entre usuario y los objetos de la interfaz gráfica o GUI.
Se presentará el manejo de eventos implementados a partir de la versiòn

JDK1.2 y usando los componentes Swing. Aunque este manejo de eventos
tambien es aplicable a los componentes AWT, se presentan aquí las versiones
bajo Swing, por cuanto son mas modernas y obviamente mas atractivo su uso e
implementación.
Eventos
Un evento se genera como respuesta a lo que el usuario realice como
interacción con un programa durante el ciclo de vida de este, sea una aplicación
o applet. Como todo en Java, los eventos son representados como objetos,
habiendo diferentes tipos de eventos, representado cada uno por una clase
diferente.
Todas las clases de eventos son subclases de la clase abstracta

java.awt.AWTevent, entre las cuales se tiene:
ActionEvent, AdjustmentEvent, AncestorEvent,

ComponentEvent, HierarchyEvent, InputMethodEvent,
InternalFrameEvent, InvocationEvent, ItemEvent, TextEvent
Otras clases de eventos que representen tipos particulares por ejemplo

MouseEvent y ActionEvent, se encuentran en el paquete
java.awt.event:
La gestión de eventos : Eventos 10 - 3
ActionEvent, AdjustmentEvent, AWTEventListenerProxy,

ComponentAdapter, ComponentEvent, ContainerAdapter,
ContainerEvent, FocusAdapter, FocusEvent,
HierarchyBoundsAdapter, HierarchyEvent, InputEvent,
InputMethodEvent, InvocationEven, ItemEvent, KeyAdapter,
KeyEvent, MouseAdapter, MouseEvent, MouseMotionAdapter,
MouseWheelEvent, PaintEvent, TextEvent, WindowAdapter,
WindowEvent.
Las interfaces en el mismo paquete son:

ActionListener AdjustmentListener AWTEventListener
ComponentListener ContainerListener FocusListener
HierarchyBoundsListener HierarchyListener
InputMethodListener ItemListener KeyListener MouseListener
MouseMotionListener MouseWheelListener TextListener
WindowFocusListener WindowListener WindowStateListener
En el diseño de un programa se debe prestar atencion solo a los ventos que se

desea el programa responda, o que interactuen con el usuario. Los siguientes
son algunos de los eventos que se pueden manejar en un programa Java:
• Clics del raton: ratón abajo cuando se presiona el boton, raton arriba cuando
se libera el boton y clic del raton cuando se oprime y suelta en el mismo
lugar.
• Movimientos del raton: Entrada o salida del señalizador del raton de un

componente o area de la ventana, o arrastre del raton, cuando se mueve el
señalizador con el boton presionado.
• Teclas: la presión de una tecla, la liberacion de una tecla y la digitación de

una tecla o sea la secuencia de presionar y liberar.
• Eventos de la interfaz del usuario: componente boton presionado,

movimiento de barras de desplazamiento, activación de menus contextuales
y otros.
Para que un evento tenga efecto, el programa debe estar en capacidad de

detectarlo (“escucharlo”) y reaccionar ante el (realizar alguna accion). Para cada
clase de evento, hay una clase del tipo interface que define uno o mas
métodos para reaccionar a los eventos generados de esa clase.
Por ejemplo, asociado con la clase ActionEvent se tiene la interface

denominada ActionListener, la cual define un método
La gestión de eventos : Eventos 10 - 4
public void actionPerformed(ActionEvent).
Una clase que desee responder a eventos del objeto dado debe implementar, por
consiguiente, la interfaz ActionListener. Este es el caso del manejo del
objeto JTextField.
Debe recordarse que, al ser una interfaz una clase donde los métodos están
declarados pero no implementados, la clase que requiera ese escucha para
alguno de sus componentes, deberá implementar todos los métodos declarados.
En el caso de ActionListener, solo hay que implementar el método
actionPerformed().
Modelo para manejo de eventos

El modelo de manejo de ventos en la versión actual de Java, se denomina de
Delegación de Eventos, el cual para controlar los eventos en un programa,
especifica que se le indique cuales eventos son los que se desea monitorear o
escuchar, así como también, especificar las acciones de respuesta a estos.
El modelo de delegacion de ventos se fundamenta en la organización de los

eventos en una jerarquía de Clases de eventos. Un evento es un objeto o
instancia de una clase de evento.En este modelo se hace uso de fuentes de
eventos transmitidos (o ejecutados) por sus orígenes (Source) y manejados por
escuchas o receptores de eventos (Listener).
La clase EventObject del paquete java.util es la superclase de todos los

eventos en el modelo de delegación de eventos. Entre estos se encuentran
KeyEvent, MouseEvent, ActionEvent y otros como subclases de
java.awt.AWTEvent.
Una fuente de eventos es cualquier objeto capaz de detectar eventos y notificar

a los escuchas de los eventos que se generen. Un receptor de eventos es una
clase o subclase, que implementa una interfaz con recepción especifica de
eventos.Existe un conjunto de clases receptoras o escuchas, con lo métodos
adecuados para el tratamiento de los eventos de su clase.
La invocación de estos métodos es el mecanismo mediante el cual el objeto

fuente notifica al receptor que uno o más eventos ha sucedido. El fuente
mantiene una lista de objetos receptores de eventos y los tipos de eventos a los
cuales está suscrito. El objeto receptor es una instancia de una clase que
implementa la interfaz EventListener heredada desde el receptor genérico
java.util.EventListener.
La gestión de eventos : Modelo para manejo de eventos 10 - 5
La lista de objetos receptores así como los tipos de eventos a los que están
suscritos, es creada en el objeto fuente mediante llamadas a los métodos cuya
forma general es,
add<TipoEvento>Listener()
por ejemplo addMouseListener(), para agregar un escucha de las
operaciones del mouse.
....
Jbutton miBoton= new Jbutton(“Boton01”);
miBoton.addMouseListener(this);
Permite registrar eventos del ratón asociados con el objeto miBoton.
Esto se denomina Registro de Receptorres específicos para la recepción de

eventos. El objeto fuente utiliza esta lista para notificar a cada receptor que ha
sucedido un evento de los que controla.
Hay algunas clases de eventos que involucran a mas de un evento, tal es el caso
del ratón. Por tanto, la clase que implementa la interfaz del ratón debe
sobreescribir todos los métodos declarados en la interfaz, tales como
mousePressed, mouseReleased, mouseClcked, mouseMoved y otros. Esto
hace un codigo innecesariamente extendido, si solo se requiere controlar un tipo
de evento, port ejemplo, mousePressed.
Para facilitar el manejo de estos eventos, se han definido un número de clases

intermedias, conocidas como clases adaptadores (Adapters), para no tener que
sobreescribir todos los métodos de la interfaz. Su mecanismo es implementar la
interfaz receptora, sobreescribiendo todos los métodos de la interfaz como
vacíos. Así una clase receptora puede definirse como una clase que extiende
una clase Adapter, en lugar de implementar una interfaz, sobreescribiendose
únicamente los métodos que sean de interes monitorear.
A este punto tenemos dos caminos para acceder a los escuchas de los eventos
para un componente específico:
• implementando la interfaz, lo cual implica sobreescribir todos sus métodos.
• Extendiendo una clase adaptadora, con lo cual se sobreescriben solo los

métodos deseados.
Por ejemplo si un applet se desea que responda con un mensaje a eventos de un

objeto de la clase Button debe tener la siguiente forma:
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import javax.swing.*;
public class MiApplet extends JApplet implements ActionListener{

String msg = " ";
int nVeces =0;
JButton miBoton; // componente
public void init (){// inicializa el applet
miBoton = new JButton("Boton 01");
miBoton.addActionListener(this);
getContentPane().add(miBoton);
}
// para responder a los eventos del boton
public void actionPerformed(ActionEvent evento){
nVeces++;
showStatus("ha pulsado el boton "+nVeces+" veces");
}
}
Que da como resultado despues de presionar el boton un numero de veces como

se ilustra en las figuras mas adelante.
Implementando la interfaz ActionListener, un objeto es capaz de escuchar

eventos action. Pero antes de que pueda escuchar cualquier evento, este debe
ser registrado como un escuchador de action, ActionListener. Cuando el
usuario da un click en el ratón, un evento action se genera. Cada componente
que pueda generar eventos action, debe tener un método llamado
addActionListener. Este método es usado para registrar los escuchas de
eventos de action con el componente. Cuando el componente genera un evento
de action, notifica al escucha de action registrado llamando el método
actionPerformed().
En el ejemplo anterior se crea un componente miBoton del tipo JButton ,

para lo cual se utiliza el método init() del applet. Cuando se da click en el
raton, el applet llama al método, miBoton.addActionListener(this).La
notificación es enviada al applet, mediante el llamado al método
actionPerformed(). Cuando este método es llamado se le pasa un
parámetro del tipo ActionEvent. Este parámetro contiene información acerca
del evento en particular que se ha generado, ya que cada evento es representado
por una clase diferente debido a que cada tipo de evento requiere diferente
información para ser enviada a sus escuchas.
Una vez se le dá control al método actionPerformed, se asigna un valor a la

cadena msg, la cual tenía asignado “ “, se invoca al método repaint() del
applet, el cual invoca luego a paint(), donde se dibuja el mensaje,
En la raiz de la jerarquía de eventos se encuentra EventObject que se

encuentra en java.util. Contiene dos métodos se pueden utilizar para acceder
a información sobre eventos:
Object getSource(): retorna la fuente del evento, permitiendo con este

método identificar el objeto que ha generado el evento. La siguiente instrucción,
que debe ir dentro del cuerpo del método actionPerformed(), ilustra la
utilización de este método para establecer si se ha generado un evento por el
objeto miBoton.
if(evento.getSource()==miBoton) ...
la expresión dentro del if será verdadera si el evento ha sido generado por el

objeto miBoton.
Un evento se lo representa mediante un objeto tipo evento que tiene tanto los
atributos y los métodos para trabajar con el. Los datos de un objeto evento se
pueden acceder y establecer por medio de los métodos.
La clase AWEvent
Los métodos de una interfaz escucha de eventos del AWT tienen un solo
argumento, que es una instancia de una clase que desciende de la clase
java.awt.AWTEvent. Esta clase hereda un método muy útil de la clase
java.util.EventObject,
Object getSource(Action evento)
el cual se encarga de devolver el objeto que generó el evento, por ejemplo en el

siguiente programa para conocer cual es el boton que se ha presionado en el
método actionPerformed(Action event):
Las siguientes figuras ilustran la interfaz, desde el inicio hasta la presion de un

boton cualquiera y exhibir algun mensaje dibujado en la ventana del applet.
La gestión de eventos : La clase AWEvent 10 - 9
import java.awt.*;
public class Botones01 extends Applet implements ActionListener

{
String msg = " ";
Button botonSi,botonNo,botonOtro;
public void init (){
botonSi = new Button("si");
botonSi.addActionListener(this);
botonNo = new Button("no");
botonNo.addActionListener(this);
botonOtro = new Button("otro");
botonOtro.addActionListener(this);
add(botonSi);
add(botonNo);
add(botonOtro);
}
if(evento.getSource()== botonSi)
msg = ("ha pulsado el boton si");
else if(evento.getSource()==botonNo)
msg = "ha pulsado el boton no";
else
if(evento.getSource()==botonOtro)
msg = "ha pulsado boton otro";
repaint();
}
public void paint(Graphics g){
g.drawString(msg,6,100);
}
}
Un ejemplo mas elaborado lo consituye el siguiente ejemplo el cual consiste en

un tablero de jugar triqui. Cada jugador marca una posición en un tablero de
tres por tres. Gana el jugador que logre colocar tres posiciones en linea a su
favor. Por ejemplo un jugador las coloca de color rojo y el otro de color azul. La
figura muestra la interfaz para este juego.
La siguiente figura ilustra el estado del tablero despues de cuatro jugadas.

Observese el mensaje en la linea de estado, acerca del ultimo boton presionado.
El siguiente es el código del applet Triqui01:
import java.awt.*;
public class Triqui01 extends JApplet implements
ActionListener {
int turno = -1;
JButton jButton11;
JButton jButton12;
JButton jButton13;
JButton jButton14;
JButton jButton15;
JButton jButton16;
JButton jButton17;
JButton jButton18;
JButton jButton19;
public Triqui01() {
jButton11 = new JButton();
GridLayout miLayout= new GridLayout(3,3);
getContentPane().setLayout(miLayout);
jButton11.setText("jButton11");
jButton11.addActionListener(this);
getContentPane().add(jButton11);
}
public void actionPerformed(ActionEvent evt) {
if(evt.getSource()==jButton19){
if (turno == -1){ jButton19.setBackground(Color.red);
turno=-turno;}
else{ jButton19.setBackground(Color.blue);
turno=-turno;} // Add your handling code here:
jButton19.setEnabled(false);
showStatus("presiono jButton19");}
if (turno == -1){ jButton18.setBackground
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
(Color.red);
turno=-turno;}
turno=-turno;}
showStatus("presiono jButton12"); }
(Color.red);
turno=-turno;}
turno=-turno;}
showStatus("presiono jButton11");
}
}
}
Las subclases de AWTEvent definen métodos similares, por ejemplo, la clase

ComponentEvent define un método getComponent que retorna el componente

(Component) que ha generado el evento.
java.lang.Object
java.util.EventObject
AWTEvent
ActionEvent AdjustmentEvent ComponentEvent ItemEvent TextEvent
ContainerEvent FocusEvent InputEvent WindowEvent
KeyEvent MouseEvent
Tipos de eventos
Los eventos se dividen en dos clases: de bajo nivel o de componente, y de alto
nivel o semánticos.
Eventos de bajo nivel o de componente

Son aquellos que representan una entrada sobre un componente visual de un
sistema de ventanas en la pantalla. Hacer click con el ratón, oprimir una tecla.
La clase Component del AWT, define los métodos de procesamiento y registro

de escucha para eventos a nivel de componente. Por ejemplo el método
addMouseListener(), que agrega un escucha para recibir eventos del ratón
en un componente,o addKeyListener() para agregar un escucha que reciba
eventos del teclado en un componente.
Todos los eventos a nivel de componente son subclases de java.awt.event, tales

como :
La gestión de eventos : Tipos de eventos 10 - 15
• ComponentEvent: Evento de bajo nivel que indica que un componente se

ha movido, cambiado su tamaño, o cambiada su visibilidad.
• FocusEvent: Evento generado por un componente, que indica que el

componente ha ganado o perdido su enfoque en el teclado.
• InputEvent: es la clase raiz para todos los eventos de entrada a nivel de

componente. Los eventos de entrada son despachados a los escuchas antes
que que sean procesados normalmente por las fuentes donde ellos se
generaron.
• KeyEvent: indica que se ha presionado una tecla en un componente. Este

evento se genera por un objeto componente, por ejemplo un campo de texto,
cuando una tecla es presionada, suelta, o se genera un carácter con ella
presionándola y soltandola.
• MouseEvent: Evento que indica que ha sucedido una accion con el ratón
sobre algún componente. Estas acciones pueden ser:
Eventos simples del ratón: un boton presionado, suelto o liberado,

presionado y liberado, el cursor del ratón entra o sale de un componente.
Eventos de movimiento del ratón: el ratón se ha movido, el ratón se ha

movido con un boton presionado (dragged).
• ContainerEvent: Evento que indica que el contenido de un contenedor ha

cambiado en virtud de haberse agregado o suprimido un componente.
• WindowEvent: Evento que indica que una ventana ha cambiado su estado,

por ejemplo cuando se abre, se cierra, se activa o desactiva, cuando se
minimiza (iconified) o restaura (deconified).
Eventos semánticos o de alto nivel

Aquellos que representan la función o significado de más alto nivel de un
evento, por ejemplo hacer doble clik con el ratón en una línea de texto. Los
siguientes son algunos eventos semánticos:
• ActionEvent: evento que indica que ha sucedido una acción definida en un

componente, por ejemplo presionar un botón para que realice una función
definida para ese componente.
• AdjustmentEvent: este evento se genera cuando se ajusta el valor de de un

objeto ajustable.
La gestión de eventos : Tipos de eventos 10 - 16
• ItemEvent:Este evento indica que un elemento ha sido seleccionado o

deseleccionado, cambiando su estado, por ejemplo en una lista al seleccionar
uno de sus elementos.
• TextEvent: evento que indica que un objeto texto por ejemplo

TextComponent ha cambiado su texto.
Escuchadores de eventos
El control de eventos en un programa, aplicación o applet, se lleva a cabo
mediante el establecimiento de objetos escuchas (listeners) y registrarlos con
sus orígenes (sources). Los métodos de escucha se registran con
addXyzListener (para agregarlo) y removeXyzListener (para
removerlo). En donde Xyz es el nombre de la interfaz usada.
Igualmente estas se dividen en interfaces alto y bajo nivel.
De bajo nivel
Las interfaces de bajo nivel para escuchas son las siguientes:
• ComponentListener: Interface escucha que recibe eventos de

componentes. Una clase que requiera procesar un evento de un componente
implementa esta interface y todos los métodos que contiene o extiende la
clase abstracta ComponentAdapter,sobreescribiendo únicamente los
métodos de interes. El objeto escucha creado de esa clase es registrado con el
componente usando el método addComponentListener .
• ContainerListener: interface escucha que recibe eventos de

contenedores. Una clase que requiera procesar un evento de un contenedor
implementa esta interface y todos los métodos que contiene o extiende la
clase abstracta ContainerAdapter,sobreescribiendo únicamente los
métodos de interes. El objeto escucha creado de esa clase es registrado con el
componente usando el método addContainerListener. Cuando el
contenedor cambia, bien sea porque se ha agregado o eliminado un
componente, el método referido en el objeto escucha es invocado y el
ContainerEvent se le suministra.
• FocusListener:Interface para recibir el foco del teclado sobre un

componente. En Java cuando un componente tiene foco, hace referencia a
que las entradas del teclado se dirigen a ese componente.La clase interesada
en recibir foco del teclado sobre un componente implemneta esta interface o
extiende la clase abstracta FocusAdapter. El objeto escucha creado se
registra con el componente usando el método addFocusListener.
La gestión de eventos : Escuchadores de eventos 10 - 17
Cuando el componente gana (método focusGained()) o pierde el foco

(focusLost()) del teclado se invoca el respectivo método y el FocusEvent se
le suministra.
• KeyListener: interface para recibir eventos generados por el teclado,

mediante presion de teclas (keystrokes), soltar la tecla o presionar y soltar
una tecla. La clase intersada en procesar eventos de teclado implementa esta
interface o extiende la clase abstracta KeyAdapter. El objeto escucha
creado se registra con un componente usando el método
addKeyListener. Se invoca el método relevante y se le suministra
KeyEvent.
• MouseListener:interface para recibir eventos del ratón tales como

presionar o liberar un botón, hacer clik, entrar o salir de un componente. El
movimiento y el arrastrado del ratón usan la interfaz MouseMotionListener.
Una clase que requiera procesar los eventos del ratón indicados antes, deberá
implementar esta interface o extender la clase abstracta MouseAdapter. El
objeto escucha creado es registrado con un componente usando el método
addMouseListener. Cuando sucede un evento del ratón se invoca el
método relevante en el objeto escucha y se le suministra el MouseEvent.
• MouseMotionListener: Interfaz que recibe movimientos y arrastre del

ratón. Una clase que requiera procesar este tipo de eventos debe implementar
esta interfaz o extender la clase abstracta MouseMotionAdapter. El
objeto escucha creado es registrado con un componente usando el método
addMouseMotionListener. Cuando se genera un evento de
movimiento del ratón se invoca el método relevante y se le suministra
MouseEvent.
• WindowListener: interfaz para escuchar eventos de ventana. La clase que

requiera procesar este tipo de eventos debera implementar esta interfaz o
extender la clase abstarcta WindowAdapter. El objeto escucha creado es
registrado con una ventana usando el método addWindowListener.
Cuando el estado de la ventana cambia, por ejemplo cuando se abre, se
cierra, se activa o desactiva, se minimiza o se restaura, el método respectivo
se invoca y se le suministra WindowEvent.
De alto nivel
Las interfaces de alto nivel o semántico para escuchas son las siguientes:
• ActionListener:interfaz para recibir eventos de acción sobre un

componente. La clase que requiera procesar un evento acción deberá
implementar esta interfaz y el objeto creado es registrado con el componente
La gestión de eventos : Escuchadores de eventos 10 - 18
usando el método addActionListener. Cuando el evento acción

(action) sucede se invoca el método actionPerformed del objeto, y se
le suministra un ActionEvent.
• AdjustmentListener:interfaz para recibir eventos de ajuste. La clase que

requiera procesar un evento de ajuste deberá implementar esta interfaz. El
objeto creado es registrado usando el método addAdjustmentListener.
Cuando un evento sucede se invoca el método adjustmentValueChanged
y se le suministra un AdjustmentEven.
• ItemListener: interfaz para recibir eventos tipo item, o de cambio de

estado de un elemento. La clase que requiera procesar este tipo de eventos
deberá implementar esta interfaz. El objeto creado es registrado con un
componente usando el método del componente addItemListener.
Cuando sucee un evento de selección de un elemento o ítem, el objeto
escucha itemStateChanged es invocado y se le suministra un
ItemEvent.
• TextListener: interfaz para recibir eventos de texto. La clase que requiera

procesar este tipo de eventos deberá implementar esta interfaz. El objeto
creado es registrado con un componente usando el método
addTextListener. Cuando el texto del componente cambia el método
textValueChanged es invocado y se le suministra un TextEvent.
Clases Adaptadores de eventos

Todas las fuentes de eventos soportan el multienvío de receptores, es decir que
se pueden añadir o quitar múltiples receptores de una sola fuente, de tal manera
que la notificación de que un evento se ha producido se puede enviar a uno o
mas objetos escuchas simultáneamente.
escucha de evento
objeto evento
fuente de evento escucha de evento
escucha de evento
Muchas interfaces EvenListener están diseñadas para recibir múltiples clases

de eventos, tal es el caso de la interfaz MouseListener, que permite recibir
pulsaciones del ratón, liberación del botón, entrar o salir de una ventana, etc. La
interfaz tiene declarados métodos para cada uno de estos tipos de eventos. A
diferencia de ActionListener que tiene un solo método,
actionPerformed().
La gestión de eventos : Clases Adaptadores de eventos 10 - 19
La implementación de una interfaz implica la redefinición de todos los métodos

declarados en esta, aún teniendolos que declarar como métodos vacios. Ya se ha
visto que, a fin de facilitar el uso de los escuchas, el AWT suministra un
conjunto de clases abstractas denominadas adaptadores (adapters) que
corresponden con las interfaces, de tal manera que cada adaptador implementa
una interfaz y redefine todos los métodos declarados en la interfaz como
métodos vacíos, con lo cual se redefinirán por parte del usuario sólo los
métodos requeridos, extendiendo o heredando esta clase..
De esta manera se definen receptores o escuchas extendiendo las clases

Adapters, en lugar de implementar la interfaz correspondiente redediniendo
todos sus métodos .
Debe señalarse que, se presenta un inconveniente para los applets, pues no

podrían extender una interface, pues heredan ya de por sí de JApplet.
Las clases adaptadoras en Java son las siguientes:
java.awt.ComponetAdapter
java.awt.FocusAdapter
java.awt.KeyAdapter
java.awt.MouseAdapter
java.awt.MouseMotionAdapter
java.awt.WindowAdapter
A continuación se verá la manera de implementar el manejo de eventos en Java

a traves de varias alternativas.
Manejo de eventos
Para detectar los eventos de un componente determinado se debe tener claro
cómo se usa el componente y cuales son mecanismos de implementación de su
manejador de eventos.
Como ya se indicó antes, las applets tienen problemas con el uso de los
adaptadores y deben utilizar la implementación de la interfaz. Se pueden
manejar eventos con los siguiente sesquemas:
Todo manejador de eventos requiere las siguientes partes de código:
1. Donde se declare la clase del manejador de eventos, el código especifica que

la clase o implementa un interface de oyente, o desciende una clase que
La gestión de eventos : Manejo de eventos 10 - 20
implementa un interface de oyente. Por ejemplo:

public class MiClase implements ActionListener {
Indica que la clase MiClase manejará eventos del tipo ActionEvent, por tal
razón implementará el método asociado con el escucha.
2. El código que registra un ejemplar de la clase de manejo de eventos, sobre

uno o más componentes. Por ejemplo, para el componente
algunComponente se le está acondicionando un escucha de
AactionEvent :
algunComponente.addActionListener(instanciaDeMiClase);
Por ejemplo para asignarle a un botón su escucha de eventos, se procede con el

siguiente código:
miBoton.addActionListener(this);
3. La implementación de los métodos del interface oyente, en este caso la

interfaz ActionListener tiene un sólo método a implementar,
actionListener(ActionEvent e). Por ejemplo:
public void actionPerformed(ActionEvent e) {

...//codigo para reaccionar a la accion}
Para el caso de un botón miBoton, lo que se desea es mostrar en la línea de

estado de un applet, el mensaje “Se ha presionado el boton”, tenemos:
public void actionPerformed(ActionEvent e) {
showStatus(“Se ha presionado el boton”); }
El ejemplo presentado antes con el applet MiApplet, ilustra el manejo típico de

eventos para el caso del componente Button.Un escenario de manejo de eventos
típico ocurre con los botones (JButton) versión de Button en Swing. Para
detectar cuando el usuario pulsa un botón de la pantalla (o pulsa la tecla
equivalente), un programa debe tener un objeto que implementa el interface
ActionListener. El programa debe registrar este objeto como un oyente de
actión del botón (la fuente del evento), usando el método addActionListener.
Cuando el usuario pulsa el botón de la pantalla, éste dispara el evento action,
Esto resulta en una llamada al método actionPerformed del oyente de action, el
único método del interface ActionListener). El único argumento del método es
un objeto ActionEvent que ofrece información sobre el evento y su fuente.
ActionEvent
button actionListener
Cuando el usuario pulsa un botón, los oyentes de action del botón son
notificados.Los manejadores de eventos pueden ser ejemplares de cualquier
clase. Frecuentemente, se implementan usando clases internas anónimas, lo que
puede hacer el códio algo más confuso -- hasta que hayas usado las clases
internas. El siguiente es un ejemplo de un applet bajo Swing:
import java.awt.*;
public class Applet02 extends JApplet implements ActionListener
{
int numClicks=0;
JLabel label2 = new JLabel();
public void init() {
JButton boton1 = new JButton("Soy un boton");
boton1.addActionListener(this);
getContentPane().setLayout(new GridLayout(0,1));
getContentPane().add(boton1);
label2.setLabelFor(boton1);
getContentPane().add(label2);
}
public void actionPerformed(ActionEvent e){
numClicks = numClicks+1;
label2.setText("numero de clicks = "+numClicks);}
Los Threads y el Manejo de Eventos

El código de manejo de eventos se ejecuta en un sólo thread el thread de
despacho de eventos. Esto asegura que todo manejador de eventos se terminará
de ejecutar antes de ejecutar otro. Por ejemplo, el método actionPerformed del
ejemplo anterior se ejecuta en el thread de manejo de eventos. El código de
dibujo también se realiza en el thread de despacho de eventos. Esto significa
que mientras se está ejecutando el método actionPerformed, el GUI del
programa está congelado -- no se dibujará nada ni se responderá a las
pulsaciones del ratón, por ejemplo.
Manejo de eventos ActionEvent

Si se desea manejar varios botones se tiene el siguiente código que permite
manejar los ecuchas para tres botones:
import java.awt.*;
public class Botones01 extends Applet implements ActionListener

{
String msg = " ";
Button botonSi,botonNo,botonOtro;
botonSi = new Button("si");
botonSi.addActionListener(this);
botonNo = new Button("no");
botonNo.addActionListener(this);
botonOtro = new Button("otro");
botonOtro.addActionListener(this);
add(botonSi);
add(botonNo);
add(botonOtro);
}
else
repaint();
}
public void paint(Graphics g){
g.drawString(msg,6,100);
}
}
En este caso se ha colocado un escucha del tipo ActionListener a cada uno
de los botones. En esta version se tiene un sóloi método actionPerformed
(ActionEvent e), dentro del cual se selecciona cual fué el boton que generó
el evento. El método getSource(), del evento generado, contiene el nombre
del objeto o componente que generó ese evento. Dependiendo del boton
presionado, se tomará la accion indicada en el método actionPerformed().
Otra forma de escribir los oyentes para un componente, en este caso para
eventos tipo ActionEvent, es mediante clases internas anónimas asignadas a
cada componente, como en la siguiente version de la clase Botones01b:
import java.awt.*;
public class Botones01b extends JApplet {
JButton botonSi,botonNo,botonOtro;
FlowLayout miFlow = new FlowLayout();
JLabel miEtiqueta = new JLabel("Soy una etiqueta");
Container contentPane = getContentPane();

contentPane.setLayout(miFlow);
botonSi = new JButton("si");
botonSi.addActionListener(new ActionListener() {
miEtiqueta.setText("Ha presionado boton Si");
}
});
botonNo = new JButton("no");

botonNo.addActionListener(new ActionListener() {
miEtiqueta.setText("Ha presionado boton No");
}
});
botonOtro = new JButton("otro");

botonOtro.addActionListener(new ActionListener() {
miEtiqueta.setText("Ha presionado boton Otro");
}
});
contentPane.add(botonSi);
contentPane.add(botonNo);
contentPane.add(botonOtro);
contentPane.add(miEtiqueta);
}
Obsérvese cómo se ha codificado el método actionperformed para el caso

del botón no.
botonNo.addActionListener(new ActionListener() {
miEtiqueta.setText("Ha presionado boton No");
}
});
De igual manera, con este método no es necesario incluir la palabra

implements de la interface.
Otra forma es mediante clases internas, en este caso se ha definido la clse

einterna MiManejador donde se manejarán las acciones de los botones. Esta
clase debe implementar ActionListener:
import java.awt.*;
public class Botones01c extends JApplet{
String msg =" ";
JLabel miEtiqueta = new JLabel("Soy una etiqueta");

contentPane.setLayout(miFlow);
botonSi.addActionListener(new MiManejador());

botonNo.addActionListener(new MiManejador());

botonOtro.addActionListener(new MiManejador());
contentPane.add(botonSi);
contentPane.add(botonNo);
contentPane.add(botonOtro);
contentPane.add(miEtiqueta);
}
class MiManejador implements ActionListener{
else
miEtiqueta.setText(msg);}}
En todos los tres casos se presentarán los mismos resultados.
Un ejemplo de uso para el componente JTextField y botones, corresponde a la

siguiente interfaz GUI:
import java.awt.*;
public class TextDemo extends JApplet implements ActionListener

{
JTextField textField1, textField2;
JLabel label1, label2;
String text="Holas";
JButton boton1, boton2, boton3, boton4;
JTextArea textArea;
String newline = "\n";
public void init() {
boton1 = new JButton("+");
boton2 = new JButton("-");
boton3 = new JButton("*");
boton4 = new JButton("/");
textField1 = new JTextField(20);

textField2 = new JTextField(20);
textField2.addActionListener(this);
label1= new JLabel("Datos de a");
label2 = new JLabel("Datos de b");
textArea = new JTextArea(5, 20);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea,
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
FlowLayout gridBag = new FlowLayout();

contentPane.setLayout(gridBag);
contentPane.add(label1);
contentPane.add(textField1);
contentPane.add(label2);
contentPane.add(textField2);
contentPane.add(boton1);
contentPane.add(boton4);contentPane.add(scrollPane);}

int valor1, valor2, suma;
text = textField1.getText();
valor1 = Integer.parseInt(text);
text = textField2.getText();
valor2 = Integer.parseInt(text);
suma=valor1+valor2;
textArea.append("suma " +valor1+" + "+valor2+" = "+
suma+newline);
}
}
Otro ejemplo de uso de ActionListener con clases internas para el manejo de los
eventos.
import java.awt.*;
public class TextFieldTest extends JFrame {

private JTextField text1, text2, text3;
JLabel label1, label2, label3, label4;
private JPasswordField password;
public TextFieldTest()
{
super( "Uso de JTextField y JPasswordField" );
Container c = getContentPane();
c.setLayout( new FlowLayout() );
label1 = new JLabel("Campo texto 1");
c.add(label1);
// se construye un textfield de tamaño 10
text1 = new JTextField( 10 );
c.add( text1 );

c.add(label2);
// se construye textfield con texto

text2 = new JTextField( "Digite texto aqui" );
c.add( text2 );

c.add(label3);
// construye textfield no editable con texto y tamaño 20

text3 = new JTextField( "Campo de texto no editable",
20 );
text3.setEditable( false );
c.add( text3 );

c.add(label4);
// construye password con texto por defecto

password = new JPasswordField( "Esto no se puede ver" );
c.add( password );
TextFieldHandler handler = new TextFieldHandler();

text1.addActionListener( handler );
password.addActionListener( handler );
setSize( 250, 200 );

show();
}
public static void main( String args[] )

{
TextFieldTest app = new TextFieldTest();
app.addWindowListener(
new WindowAdapter() {
public void windowClosing( WindowEvent e )
{
System.exit( 0 );
}
}
);
}
// clase interna para manejo de los eventos ActionEvent

private class TextFieldHandler implements ActionListener {
public void actionPerformed( ActionEvent e )
{
String s = "";
if ( e.getSource() == text1 )
s = "text1: " + e.getActionCommand();
else if ( e.getSource() == text2 )
else if ( e.getSource() == text3 )
else if ( e.getSource() == password ) {
JPasswordField pwd =
(JPasswordField) e.getSource();
s = "password: " +
new String( pwd.getPassword() );
}
JOptionPane.showMessageDialog( null, s );
}
}
}
Manejo de ItemListener
Es la interfaz escucha del tipo de eventos item. La clase interesada en procesar
este tipo de eventos debe implementar esta interface. El objeto creado para
escuchar debe usar el método addItemListener. Cuando un evento resultante de
la seleccion del item sucede se invoca el método itemStateChanged().
La gestión de eventos : Manejo de ItemListener 10 - 30
Tiene un solo método itemStateChanged(ItemEvent e). El siguiente

ejmplo ilustra el uso de la interfaz ItemListener:
import java.awt.*;
public class CheckBoxTest extends JFrame {

private JTextField t;
private JCheckBox bold, italic, tipo, color;
public CheckBoxTest()
{
super( "Prueba de JCheckBox" );
c.setLayout(new FlowLayout());
t = new JTextField( "Mire el cambio de tipo", 30 );

t.setFont( new Font( "TimesRoman", Font.PLAIN, 14 ) );
c.add( t );
// crea objetos checkbox

bold = new JCheckBox( "Bold" );
c.add( bold );
italic = new JCheckBox( "Italic" );

c.add( italic );
tipo= new JCheckBox(" Arial 15");

c.add(tipo);
color= new JCheckBox(" Color rojo");
c.add(color);
CheckBoxHandler handler = new CheckBoxHandler();

bold.addItemListener( handler );
italic.addItemListener( handler );
tipo.addItemListener(handler);
color.addItemListener(handler);
setSize( 350, 120 );

show();
}

{
CheckBoxTest app = new CheckBoxTest();
{
System.exit( 0 );
}
}
);
}
private class CheckBoxHandler implements ItemListener {

private int valBold = Font.PLAIN;
private int valItalic = Font.PLAIN;
public void itemStateChanged( ItemEvent e )

{
if ( e.getSource() == bold )
if ( e.getStateChange() == ItemEvent.SELECTED )
valBold = Font.BOLD;
else
valBold = Font.PLAIN;
if ( e.getSource() == italic )
if ( e.getStateChange() == ItemEvent.SELECTED )
valItalic = Font.ITALIC;
else
valItalic = Font.PLAIN;
t.setFont(
new Font( "TimesRoman", valBold + valItalic, 14 ) );
if(e.getSource()==tipo){
if( e.getStateChange() == ItemEvent.SELECTED )
t.setFont(new Font( "Arial", Font.BOLD, 15 ));}
if(e.getSource()==color){
if( e.getStateChange() == ItemEvent.SELECTED )
t.setForeground(java.awt.Color.red);
else
t.setForeground(java.awt.Color.black);
}
t.repaint();
}
}
}
Obsérvese el uso de una clase interna para el manejo de los eventos del
JcheckBox.
Manejo de Radio Buttons

Son similares a los JcheckBox, en cuanto pueden tener dos estados,
seleccionado o deseleccionado. Sin embargo estos botones aparecen
conformando grupos, en donde uno solo puede ser seleccionado, ya que
representan opciones mutuamente excluyentes. Se agrupan dentro de un objeto
del tipo ButtonGroup.
// Creacion de botones de radio usando ButtonGroup

JRadioButton.
import java.awt.*;
public class RadioButtonTest extends JFrame {

private JTextField t;
private Font plainFont, boldFont,
La gestión de eventos : Manejo de Radio Buttons 10 - 33
italicFont, boldItalicFont;
private JRadioButton plain, bold, italic, boldItalic;
private ButtonGroup radioGroup;
public RadioButtonTest()
{
super( "Ejemplo botones " );
t = new JTextField( "Mireme como cambio de forma", 25 );

c.add( t );
// Crea botones
plain = new JRadioButton( "Plain", true );
c.add( plain );
bold = new JRadioButton( "Bold", false);
c.add( bold );
italic = new JRadioButton( "Italic", false );
c.add( italic );
boldItalic = new JRadioButton( "Bold/Italic", false );
c.add( boldItalic );
// registra eventos
RadioButtonHandler handler = new RadioButtonHandler();
plain.addItemListener( handler );
bold.addItemListener( handler );
italic.addItemListener( handler );
boldItalic.addItemListener( handler );
// agrupa los botones

radioGroup = new ButtonGroup();
radioGroup.add( plain );
radioGroup.add( bold );
radioGroup.add( italic );
radioGroup.add( boldItalic );
plainFont = new Font( "TimesRoman", Font.PLAIN, 14 );

boldFont = new Font( "TimesRoman", Font.BOLD, 14 );
italicFont = new Font( "TimesRoman", Font.ITALIC, 14 );
boldItalicFont =
new Font( "TimesRoman", Font.BOLD + Font.ITALIC, 14 );
t.setFont( plainFont );
setSize( 300, 100 );

show();
}

{
RadioButtonTest app = new RadioButtonTest();
La gestión de eventos : Manejo de Radio Buttons 10 - 34
{
System.exit( 0 );
}
}
);
}
private class RadioButtonHandler implements ItemListener {

{
if ( e.getSource() == plain )
t.setFont( plainFont );
else if ( e.getSource() == bold )
t.setFont( boldFont );
else if ( e.getSource() == italic )
t.setFont( italicFont );
else if ( e.getSource() == boldItalic )
t.setFont( boldItalicFont );
t.repaint();
}
}
}
Manejo de ComboBox
Un lista desplegable hacia abajo (drop-down-list) permite seleccionar un
elemento de esta. Se implementan con la clase JcomboBox, el cual genera
eventos del tipo ItemEvent, así como los componentes JcheckBox y
JradioButtons.
// Uso del JComboBox para seleccionar una imagen para el

icono de
La gestión de eventos : Manejo de ComboBox 10 - 35
// una etiqueta
import java.awt.*;
public class ComboBoxTest extends JFrame {

private JComboBox images;
private JLabel label;
private String names[] =
{ "smile01.gif", "smile02.gif",
"smile03.gif", "llora01.gif", "susto.gif" };
private Icon icons[] =
{ new ImageIcon( names[ 0 ] ),
new ImageIcon( names[ 1 ] ),
new ImageIcon( names[ 4 ] ) };
public ComboBoxTest()
{
super( "Chequeo de JComboBox" );
images = new JComboBox( names );

images.setMaximumRowCount( 4 );
images.addItemListener(
new ItemListener() {
{
label.setIcon(
icons[ images.getSelectedIndex() ] );
}
}
);
c.add( images );
label = new JLabel( icons[ 0 ] );

c.add( label );
setSize( 350, 100 );

show();
}

{
ComboBoxTest app = new ComboBoxTest();
La gestión de eventos : Manejo de ComboBox 10 - 36
{
System.exit( 0 );
}
}
);
}
}
Manejo de oyentes del mouse

Los eventos del mouse suceden cuando el usuario utiliza el ratón para
interactuar con algún componente de la ventana de su programa.
Los eventos del mouse se han agrupado bajo dos interfaces: MouseListener y
MouseMotionListener. Estas interfaces pueden ser implementadas por el
programa que las requiera, con la condición de tener que implementar todos los
métodos, para lo cual se dejarán vacios los no requeridos.
La alternativa de utilizar la clase adaptadora respectiva, MouseAdapter y

MouseMotionAdapter. El uso de estas implica heredarlas e implementar
solamente el método o los métodos deseados. Como ya se ha visto en las
Applets se dificulta el uso de la clase adaptadora.
Metodos de MouseListener
void mouseClicked(MouseEvent e)
Invocado cuando el mouse se ha dado un click sobre algún
componente.
void mouseEntered(MouseEvent e)
Invocado cuando el mouse entra a algún componente.
void mouseExited(MouseEvent e)
Invocado cuando el mouse sale de un componente.
void mousePressed(MouseEvent e)
Invocado cuando el mouse es presionado sobre un componente.
void mouseReleased(MouseEvent e)
Invocado cuando el mouse se ha liberado sobre un componente.
La gestión de eventos : Manejo de oyentes del mouse 10 - 37
Su clase adaptadora MouseAdapter
Metodos de MouseAdapter
void mouseClicked(MouseEvent e)
Invocado cuando el mouse se ha dado un click sobre
algún componente.
void mouseEntered(MouseEvent e)
Invocado cuando el mouse entra a algún componente.
void mouseExited(MouseEvent e)
Invocado cuando el mouse sale de un componente.
void mousePressed(MouseEvent e)
Invocado cuando el mouse es presionado sobre un
componente.
void mouseReleased(MouseEvent e)
Invocado cuando el mouse se ha liberado sobre un
componente.
Los métodos de la interfaz MouseMotionListener
Metodos de MouseMotionListener
void mouseDragged(MouseEvent e)
Invocado cuando el botón del mouse se presiona y se
arrastra sobre un componente.
void mouseMoved(MouseEvent e)
Invocado cuando el mouse se ha movido sobre un
componente.
Y su clase adaptadora MouseMotionAdapter
Metodos de MouseMotionAdapter
void mouseDragged(MouseEvent e)
Invocado cuando el botón del mouse se presiona y se
arrastra sobre un componente.
void mouseMoved(MouseEvent e)
Invocado cuando el mouse se ha movido sobre un
componente.
La clase MouseEvent
Como se puede observar, todos los métodos de los escuchas del mouse tienen
como argumento un objeto MouseEvent.
Los siguientes son los métodos de la clase MouseEvent.
Metodos clase MouseEvent

int getButton()
Retorna cual de los botones se ha presionado.
int getClickCount()
Retorna el numero de clicks del mouse sobre un
componente.
static St getMouseModifiersText(int modifiers)
ring
Retorna una cadena quie describe las teclas
modificadoras que se han presionado, tales como "Shift", o
"Ctrl+Shift".
Point getPoint()
Retorna los valores x,y de la posición donde se
generó el evento relativo al componente.
int getX()
Retorna la posición horizontal x del evento generado
en el componente.
int getY()
Retorna la posición vertical y del evento generado en
el componente.
String paramString()
Retorna una cadena identificando el evento.
void translatePoint(int x, int y)

Traslada el sistema coordenado a una nueva posición
indicada por la adición de los valores especificados x
(horizontal), y (vertical).
Ejemplo de MouseListener
import java.awt.*;
public class Botones01d extends JApplet implements MouseListener
{
String msg = " ";
Container contenedor = getContentPane();
contenedor.setLayout(miFlow);
botonSi.addMouseListener(this);
botonNo.addMouseListener(this);
botonOtro.addMouseListener(this);
contenedor.add(botonSi);
contenedor.add(botonNo);
contenedor.add(botonOtro);}
public void mouseEntered(MouseEvent evt){
if(evt.getSource()== botonSi)
msg = ("ha entrado a si");
else if(evt.getSource()==botonNo)
msg = "ha entrado a boton no";
else
if(evt.getSource()==botonOtro)
msg = "ha entrado a boton otro";
showStatus(msg);}
public void mouseClicked(MouseEvent evt){
msg = ("ha dado click en si");
msg = "ha dado click en no";
else
msg = "ha dado click en otro";
showStatus(msg);}
public void mouseReleased(MouseEvent evt){
msg = ("ha soltado mouse en si");
msg = "ha soltado mouse en no";
else
msg = "ha soltado mouse en otro";
showStatus(msg);
}
public void mousePressed(MouseEvent evt){
msg = ("ha presionado mouse en si");
msg = "ha presionado mouse en no";
else
msg = "ha presionado mouse en otro";
showStatus(msg);
}
public void mouseExited(MouseEvent evt){
msg = ("ha salido de si");
msg = "ha salido de no";
else
msg = "ha salido de otro";
showStatus(msg);
}
}
Otro ejemplo de uso de MouseListener con campos de etiqueta:

import java.awt.*;
public class LabelTest extends JFrame implements MouseListener{

private JLabel label1, label2, label3, label4;
String msg, salida =" ";
public LabelTest()
{
super( "Chequeo de JLabel" );
Icon mi = new ImageIcon("tb.gif");

label4 = new JLabel( "Salida de movimientos del mouse " ,
mi,SwingConstants.LEFT );
label4.setToolTipText( "Etiqueta 4" );
c.add( label4 );
label1 = new JLabel( "Etiqueta con texto" );

label1.addMouseListener(this);
c.add( label1 );
Icon bug = new ImageIcon( "bug1.gif" );
label2 = new JLabel( "Etiqueta con texto e icono",
bug, SwingConstants.LEFT );
c.add( label2 );
label3 = new JLabel();
label3.setText( "Etiqueta con texto e icono abajo" );
label3.setIcon( bug );
label3.setHorizontalTextPosition(
SwingConstants.CENTER );
label3.setVerticalTextPosition(
SwingConstants.BOTTOM );
c.add( label3 );
setSize( 275, 200);

show();
}
public void mouseEntered(MouseEvent evt){
if(evt.getSource()== label1)
msg = ("ha entrado a Etiqueta 1");
else if(evt.getSource()==label2)
msg = "ha entrado a Etiqueta 2";
else
if(evt.getSource()==label3)
msg = "ha entrado a Etiqueta 3";
salida+=msg +"\n";
label4.setText(msg);}
public void mouseClicked(MouseEvent evt){}
public void mouseReleased(MouseEvent evt){}
public void mousePressed(MouseEvent evt){}
public void mouseExited(MouseEvent evt){}

{
LabelTest app = new LabelTest();
{
System.exit( 0 );
}
}
);
}
}

Eventos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Eventos

Uploaded by

Copyright:

Available Formats

La gestión de eventos 10 - 1

Como ya se ha indicado antes, los programas tipo applet se basan en eventos,

por ejemplo, minimizar o restaurar una ventana, presionar un objeto botón

El paquete java.awt y java.awt.event contienen las clases e interfaces

Un objeto del tipo JTextField, por ejemplo, representa un componente de

El manejo de eventos involucra, por tanto, métodos que se llaman de manera

Se presentará el manejo de eventos implementados a partir de la versiòn

Todas las clases de eventos son subclases de la clase abstracta

ActionEvent, AdjustmentEvent, AncestorEvent,

Otras clases de eventos que representen tipos particulares por ejemplo

ActionEvent, AdjustmentEvent, AWTEventListenerProxy,

Las interfaces en el mismo paquete son:

En el diseño de un programa se debe prestar atencion solo a los ventos que se

• Movimientos del raton: Entrada o salida del señalizador del raton de un

• Teclas: la presión de una tecla, la liberacion de una tecla y la digitación de

• Eventos de la interfaz del usuario: componente boton presionado,

Para que un evento tenga efecto, el programa debe estar en capacidad de

Por ejemplo, asociado con la clase ActionEvent se tiene la interface

public void actionPerformed(ActionEvent).

Modelo para manejo de eventos

El modelo de delegacion de ventos se fundamenta en la organización de los

La clase EventObject del paquete java.util es la superclase de todos los

Una fuente de eventos es cualquier objeto capaz de detectar eventos y notificar

La invocación de estos métodos es el mecanismo mediante el cual el objeto

Jbutton miBoton= new Jbutton(“Boton01”);

Permite registrar eventos del ratón asociados con el objeto miBoton.

Esto se denomina Registro de Receptorres específicos para la recepción de

Para facilitar el manejo de estos eventos, se han definido un número de clases

• implementando la interfaz, lo cual implica sobreescribir todos sus métodos.

• Extendiendo una clase adaptadora, con lo cual se sobreescriben solo los

Por ejemplo si un applet se desea que responda con un mensaje a eventos de un

public class MiApplet extends JApplet implements ActionListener{

Que da como resultado despues de presionar el boton un numero de veces como

Implementando la interfaz ActionListener, un objeto es capaz de escuchar

En el ejemplo anterior se crea un componente miBoton del tipo JButton ,

Una vez se le dá control al método actionPerformed, se asigna un valor a la

En la raiz de la jerarquía de eventos se encuentra EventObject que se

Object getSource(): retorna la fuente del evento, permitiendo con este

la expresión dentro del if será verdadera si el evento ha sido generado por el

Object getSource(Action evento)

el cual se encarga de devolver el objeto que generó el evento, por ejemplo en el

Las siguientes figuras ilustran la interfaz, desde el inicio hasta la presion de un

public class Botones01 extends Applet implements ActionListener

Un ejemplo mas elaborado lo consituye el siguiente ejemplo el cual consiste en

La siguiente figura ilustra el estado del tablero despues de cuatro jugadas.

El siguiente es el código del applet Triqui01:

Las subclases de AWTEvent definen métodos similares, por ejemplo, la clase

ComponentEvent define un método getComponent que retorna el componente

ActionEvent AdjustmentEvent ComponentEvent ItemEvent TextEvent

ContainerEvent FocusEvent InputEvent WindowEvent

Eventos de bajo nivel o de componente

La clase Component del AWT, define los métodos de procesamiento y registro

Todos los eventos a nivel de componente son subclases de java.awt.event, tales

• ComponentEvent: Evento de bajo nivel que indica que un componente se

• FocusEvent: Evento generado por un componente, que indica que el

• InputEvent: es la clase raiz para todos los eventos de entrada a nivel de

• KeyEvent: indica que se ha presionado una tecla en un componente. Este

Eventos simples del ratón: un boton presionado, suelto o liberado,

Eventos de movimiento del ratón: el ratón se ha movido, el ratón se ha

• ContainerEvent: Evento que indica que el contenido de un contenedor ha

• WindowEvent: Evento que indica que una ventana ha cambiado su estado,

Eventos semánticos o de alto nivel

• ActionEvent: evento que indica que ha sucedido una acción definida en un