Eventos_Parte2

Esta es una vista previa del archivo. Inicie sesión para ver el archivo original

EVENTOS EN JAVA – PARTE II 
ACTIONLISTENER 
 
La mayoría de los eventos a los que un programa responderá son generados cuando 
el usuario interactúa con un programa basado en GUI. Dichos eventos se pasan al 
programa de muchas formas diferentes, con el método específico dependiente del 
evento actual. Hay muchos tipos de eventos, incluidos aquellos que son generados 
por el ratón, el teclado, y otros controles GUI como los botones, scrollbar o 
checkbox.(sCHILDT, 2009) 
 
 
Contenido 
Introducción ............................................................................................................................................... 1 
¿Que son los eventos? .............................................................................................................................. 1 
Fuentes de eventos .................................................................................................................................... 1 
Auditores de eventos ................................................................................................................................. 3 
Clases de eventos ....................................................................................................................................... 3 
La clase ActionEvent .................................................................................................................................. 4 
Fuentes de eventos .................................................................................................................................... 5 
Las interfaces de auditores de eventos .................................................................................................... 6 
La interfaz ActionListener .......................................................................................................................... 6 
Uso del modelo de delegación de eventos .............................................................................................. 6 
Clases internas anónimas .......................................................................................................................... 7 
Bibliografía ................................................................................................................................................. 8 
 
 
 
1 
Introducción 
La mayoría de los eventos a los que un programa responderá son generados cuando el 
usuario interactúa con un programa basado en GUI1 . Dichos eventos se pasan al 
programa de muchas formas diferentes, con el método específico dependiente del 
evento actual. Hay muchos tipos de eventos, incluidos aquellos que son generados por 
el ratón, el teclado, y otros controles GUI como los botones, scrollbar o checkbox. 
(Schildt, 2009) 
¿Que son los eventos? 
Un evento es un objeto que describe un cambio de estado en una fuente. Se puede 
generar como consecuencia de que una persona interactúe con los elementos en una 
interfaz gráfica de usuario. Algunas de las actividades que causan la generación de 
eventos son presionar un botón, meter un carácter mediante el teclado, seleccionar un 
ítem de una lista, y hacer clic con el ratón, entre otros muchos. 
Puede ocurrir que no se provoque un evento directamente por la interacción con una 
interfaz de usuario. Por ejemplo, se puede generar un evento cuando se termina un 
cronómetro, cuando un contador pasa de un cierto valor, cuando hay un fallo de 
software o hardware, o cuando se completa una operación. El programador es libre de 
definir los eventos que uno considere mejores para su aplicación. (Schildt, 2009) 
Fuentes de eventos 
Una fuente es un objeto que genera un evento. Esto ocurre cuando cambia de alguna 
manera el estado interno de ese objeto. Las fuentes pueden generar más de un tipo de 
eventos. 
 
1 Interfaz gráfica de usuario 
 
 
2 
Una fuente tiene que registrar los listeners para que estos reciban notificaciones sobre 
un tipo específico de evento. Cada tipo de evento tiene su propio método de registro. 
La forma general es: 
public void addTypeListener(TypeListener el) 
Donde Type es el nombre del evento y él es una referencia al listener. Por ejemplo, el 
método que registra un evento de teclado a un listener es addKeyListener( ). El método 
que registra a un listener de movimiento de ratón es addMouseMotionListener( ). 
Cuando ocurre un evento, se notifica a todos lo listeners registrados, y reciben una 
copia del objeto evento. Esto es lo que se conoce como multidifusión del evento. En 
todos los casos, las notificaciones se envían sólo a los listeners que quieren recibirlos. 
Algunas fuentes sólo permiten registrar a un listener. La forma general del método de 
registro es: 
public void addTypeListener(TypeListener el) 
 throws java.util.TooManyListenersException 
Donde Type es el nombre del evento y el es una referencia al listener. Cuando se produce 
tal evento, se notifica al listener que está registrado. Esto es conocido como difusión 
única del evento. 
Una fuente también debe proporcionar un método que permita a un listener eliminar 
un registro en un tipo específico de evento. La forma general es: 
public void removeTypeListener(TypeListener el) 
Aquí, Type es el nombre del evento y el es una referencia al listener. Por ejemplo, para 
borrar un listener de teclado, se llamaría a removeKeyListener( ). 
La fuente que genera eventos es la que proporciona los métodos para añadir o quitar 
listeners. Por ejemplo, la clase Component proporciona métodos para añadir o quitar 
listeners de eventos de teclado o ratón. (Schildt, 2009) 
 
 
3 
Auditores de eventos 
Nota del traductor. Los auditores de eventos son mejor conocidos por su nombre en 
inglés listener. 
Un listener es un objeto que es notificado cuando ocurre un evento. Tiene dos requisitos 
principales. Primero, tiene que ser registrado con una o más fuentes para recibir 
notificaciones sobre eventos de tipos específicos. Segundo, tiene que implementar 
métodos para recibir y procesar esas notificaciones. 
Los métodos que reciben y procesan eventos se definen en un conjunto de interfaces 
que están definidas en el paquete java.awt.event. Por ejemplo, la interfaz 
MouseMotionListener define dos métodos para recibir notificaciones cuando se arrastra 
o mueve el ratón. Cualquier objeto puede recibir y procesar uno de estos eventos, o 
ambos, si implementa esa interfaz. (Schildt, 2009) 
Clases de eventos 
Las clases que representan eventos son el núcleo del mecanismo de gestión de eventos 
de Java. Así que una discusión sobre la gestión de eventos debe comenzar con las clases 
de eventos. 
Como raíz en la jerarquía de clases de eventos Java está la clase EventObject, definida 
en el paquete java.util. Ésta es la superclase para todos los eventos. Su constructor es 
el siguiente: 
EventObject(Object src) 
Donde src es el objeto que genera ese evento. 
EventObject contiene dos métodos: getSource( ) y toString( ). El método 
getSource( ) devuelve la fuente del evento. Su forma general es la siguiente: 
Object getSource( ) 
 
 
4 
Como se esperaba, toString( ) devuelve la cadena equivalente al evento. La clase 
AWTEvent, definida dentro del paquete java.awt, es una subclase de EventObject. Esta 
es la superclase (directa o indirectamente) de todos los eventos basados en AWT 
utilizados por el modelo de delegación de eventos. Se puede utilizar el método getID( ) 
para determinar el tipo del evento. La representación de este método se muestra aquí: 
int getID( ) 
Como resumen: 
 EventObject es la superclase de todos los eventos. 
 AWTEvent es la superclase de todos los eventos AWT que se gestionan por medio 
del modelo de delegación de eventos. 
El paquete java.awt.event define muchos tipos de eventos que se generan mediante 
elementos de interfaz de usuario. La siguiente tabla enumera las clases
de eventos más 
importantes y describe brevemente cuándo se generan. Los constructores y métodos 
que se utilizan normalmente en cada clase se describen en apartados posteriores. 
(Schildt, 2009) 
En este documento hablaremos sobre la clase ActionEvent. 
La clase ActionEvent 
Según (Schildt, 2009) un evento ActionEvent se genera cuando se presiona un botón, 
se hace doble clic en un elemento de una lista, o se selecciona un elemento de un menú. 
La clase ActionEvent define cuatro constantes enteras que se pueden utilizar para 
identificar cualquier modificador asociado con este tipo de evento: ALT_MASK, 
CTRL_MASK, META_MASK y SHIFT_MASK. Además existe una constante entera, 
ACTION_PERFORMED, que se puede utilizar para identificar eventos de acción. 
 
 
 
 
5 
La clase ActionEvent tiene estos tres constructores: 
ActionEvent(Object src, int tipo, String cmd) 
ActionEvent(Object src, int tipo, String cmd, int modificadores) 
ActionEvent(Object src, int tipo, String cmd, long cuando, int modificadores) 
Donde src es una referencia al objeto que ha generado este evento. El tipo del evento 
se especifica con tipo, y la cadena correspondiente a su comando es cmd. El argumento 
modificadores indica qué teclas modificadoras (ALT, CTRL, META y/o SHIFT) se han 
presionado cuando se ha generado el evento. Y el parámetro cuando especifica cuando 
ocurrió el evento. 
Se puede obtener el nombre del comando del objeto ActionEvent invocado utilizando 
el método getActionCommand( ), como se muestra a continuación: 
String getActionCommand( ) 
Por ejemplo, cuando se presiona un botón, se genera un evento de acción que tiene un 
nombre de comando igual a la etiqueta de ese botón. El método getModifiers( ) 
devuelve un valor que indica qué tecla modificadora (ALT, CTRL, META, y/o SHIFT) se ha 
presionado cuando el evento fue generado. Su forma es la siguiente: 
int getModifiers( ) 
El método getWhen( ) devuelve el tiempo en el cuál el evento tuvo lugar. Este dato es 
conocido como la estampa en el tiempo del evento. El método getWhen( ) se muestra 
aquí: 
long getWhen( ) 
Fuentes de eventos 
La siguiente tabla lista algunos de los componentes de interfaz de usuario que pueden 
generar los eventos descritos en el apartado anterior. Además de esos elementos de 
 
 
6 
interfaz gráfica de usuario, cualquier clase derivada de Component, como Applet, 
puede generar eventos. (Schildt, 2009) 
 
Las interfaces de auditores de eventos 
Como se explicó anteriormente, el modelo de delegación de eventos tiene dos partes: 
fuentes y listeners. Los listeners se crean implementando una o más interfaces definidas 
en el paquete java.awt.event. Cuando se produce un evento, la fuente del evento invoca 
al método apropiado definido por el listener y proporciona un objeto evento como su 
argumento. En la siguiente tabla aparecen las interfaces de listener que más se utilizan, 
y también aporta una breve descripción de los métodos que definen esas interfaces. En 
las siguientes secciones se examinan los métodos específicos que hay en cada interfaz. 
(Schildt, 2009) 
La interfaz ActionListener 
Esta interfaz define el método actionPerformed( ) que se invoca cuando un evento de 
acción ocurre. Su forma general se muestra a continuación: 
void actionPerformed(ActionEvent ae) 
 
Uso del modelo de delegación de eventos 
Una vez que se ha visto la teoría sobre la que trabaja el método de delegación de 
eventos y se tiene una idea general de sus componentes, se puede comenzar a trabajar 
con él. Utilizar el método de delegación de eventos es bastante fácil. Sólo hay que seguir 
estos dos pasos: 
 
 
7 
1. Implementar la interfaz apropiada en el listener, de tal manera que reciba el tipo 
de evento deseado. 
2. Implementar el código para registrar y eliminar (si fuese necesario) el registro del 
listener como destinatario de las notificaciones de eventos. 
Hay que recordar que una fuente puede generar muchos tipos de eventos. Cada evento 
se tiene que declarar de forma separada. Asimismo, se puede registrar un objeto para 
que reciba varios tipos de eventos, pero se deben implementar todas las interfaces que 
hagan falta para recibir esos eventos. (Schildt, 2009) 
Clases internas anónimas 
Una clase interna anónima es aquella a la que no se le asigna un nombre. En la clase 
de Programación Visual II utilizamos clases anónimas para asignar manejadores de 
eventos. 
 
 
 
8 
Bibliografía 
Schildt, H. (2009). Java Manual de referencia, Séptima edición. México: McGRAW-HILL 
INTERAMERICANA EDITORES, S.A. DE C.V.