TIPOS DE EVENTOS

Tópicos avanzados de programación

5 DE FEBRERO DE 2018
DOCENTE: CARLOS ALBERTO SANCHEZ ALUMNO: JIMÉNEZ MARTÍNEZ JESÚS GPE.
Carrera: ing. En Sistemas Computacionales No.control:14660237
 2

Contenido
INTRODUCCIÓN.............................................................................................................................2

SÍNTESIS.........................................................................................................................................2

CONTENIDO....................................................................................................................................3

TIPOS DE EVENTOS.................................................................................................................3

Gestión de Eventos.....................................................................................................................5

Auditores de eventos..................................................................................................................6

Adaptadores.................................................................................................................................7
Las clases Adaptadores que se definen en el JDK 1.2 son las que se indican a
continuación:................................................................................................................................7

Interfaces de auditor que más se utilizan...........................................................................10

CONCLUSIÓN:..............................................................................................................................13

BIBLIOGRAFÍA:.............................................................................................................................13

PUNTO 2........................................................................................................................................14

EJEMPLO DE INTERACCIÖN DE ALICACIÓN....................................................................14

 3

INTRODUCCIÓN
Esta investigación abarca los tipos de eventos que ahí en una aplicación java, su
origen su interfaz y sus manejadores, además tiene su gestión de los eventos de
acurdo con cada uno de ellos.
También posee los eventos más utilizados en las aplicaciones, de acuerdo con la
librería awt ya que es la que posee la mayoría de los eventos que se anejan, y su
respectiva explicación de ellos. Por otro lado se explica las fuentes de los eventos,
esto nos indica que pueden ser de multievíos a receptores Esto significa que se
pueden añadir o quitar múltiples receptores de una sola fuente. También las
fuentes de los eventos contiene el origen de los eventos, junto con su descripción
para dar a conocer su origen. Y por último están los adaptadores de los eventos y
sus interfaces.

SÍNTESIS
Esta investigación se basa en la explicación de los eventos que existen en las
aplicaciones describiéndolas desde su origen, su interface y sus manejadores la
mayoría de los eventos que se manejan en las aplicaciones los contiene la librería
awt es el acrónimo del X Window Toolkit para Java. El cual contiene los eventos
que son manejadores de ventanas, teclado, ratón, etc. Sin este tipo de eventos no
se podría realizar las aplicaciones de forma fácil ya que el programador tendría
que aumentar su tiempo de programación.
 4

CONTENIDO

TIPOS DE EVENTOS
Los eventos se catalogan por su naturaleza, que se indicará en el miembro id de
su estructura. Los grandes grupos de eventos son:
Eventos de Ventana
Son los que se generan en respuesta a los cambios de una ventana un frame o un
dialogo.
 WINDOW_DESTROY
 WINDOW_EXPOSE
 WINDOW_ICONIFY
 WINDOW_DEICONIFY
 WINDOW_MOVED

Eventos de Teclado
Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras
un Componente tiene el foco de entrada.
 KEY_PRESS
 KEY_RELEASE
 KEY_ACTION
 KEY_ACTION_RELEASE

Eventos de Ratón
Son los eventos generados por acciones sobre el ratón dentro de los límites de un
Componente.
 MOUSE_DOWN
 MOUSE_UP
 MOUSE_MOVE
 MOUSE_ENTER
 MOUSE_EXIT
 MOUSE_DRAG

Eventos de Barras
Son los eventos generados como respuesta a la manipulación de barras de
desplazamiento (scrollbars).
 SCROLL_LINE_UP
 SCROLL_LINE_DOWN
 SCROLL_PAGE_UP
 SCROLL_PAGE_DOWN
 5

 SCROLL_ABSOLUTE

Eventos de Lista
Son los eventos generados al seleccionar elementos de una lista.
 LIST_SELECT
 LIST_DESELECT

Eventos Varios
Son los eventos generados en función de diversas acciones.
 ACTION_EVENT
 LOAD_FILE
 SAVE_FILE
 GOT_FOCUS
 LOST_FOCUS

De acuerdo con Javasoft, las principales características de partida que han

originado el nuevo modelo de manejo de eventos en el AWT, son:
o Que sea simple y fácil de aprender
o Que soporte una clara separación entre el código de la aplicación y el código del
interfaz
o Que facilite la creación de robustos controladores de eventos, con menos
posibilidad de generación de errores (chequeo más potente en tiempo de
compilación)
o Suficientemente flexible para permitir el flujo y propagación de eventos
o Para herramientas visuales, permitir en tiempo de ejecución ver cómo se
generan estos eventos y quien lo hace
o Que soporte compatibilidad binaria con el modelo anterior

Los eventos ahora están organizados en jerarquías de clases de eventos.

El nuevo modelo hace uso de fuentes de eventos (Source) y receptores de
eventos (Listener). Una fuente de eventos es un objeto que tiene la capacidad de
detectar eventos y notificar a los receptores de eventos que se han producido esos
eventos. Aunque el programador puede establecer el entorno en que se producen
esas notificaciones, siempre hay un escenario por defecto.
Un objeto receptor de eventos es una clase (o una subclase de una clase) que
implementa un interfaz receptor específico. Hay definidos un determinado número
de interfaces receptores, donde cada interfaz declara los métodos adecuados al
tratamiento de los eventos de su clase. Luego, hay un emparejamiento natural
entre clases de eventos y definiciones de interfaces. Por ejemplo, hay una clase
de eventos de ratón que incluye muchos de los eventos asociados con las
acciones del ratón, y hay un interfaz que se utiliza para definir los receptores de
esos eventos.
 6

Un objeto receptor puede estar registrado con un objeto fuente para ser notificado
de la ocurrencia de todos los eventos de la clase para los que el objeto receptor
está diseñado. Una vez que el objeto receptor está registrado para ser notificado
de esos eventos, el suceso de un evento en esta clase automáticamente invocará
al método sobrescrito del objeto receptor. El código en el método sobrescrito debe
estar diseñado por el programador para realizar las acciones específicas que
desee cuando suceda el evento.
Algunas clases de eventos, como los de ratón, involucran a un determinado
conjunto de eventos diferentes. Una clase receptor que implemente el interfaz que
recoja estos eventos debe sobrescribir todos los métodos declarados en el
interfaz. Para prevenir esto, de forma que no sea tan tedioso y no haya que
sobrescribir métodos que no se van a utilizar, se han definido un conjunto de
clases intermedias, conocida como clases Adaptadoras (Adapter).
Estas clases Adaptadores implementan los interfaces receptor y sobrescriben
todos los métodos del interfaz con métodos vacíos. Una clase receptor puede
estar definida como clase que extiende una clase Adapter en lugar de una clase
que implemente el interfaz. Cuando se hace esto, la clase receptor solamente
necesita sobrescribir aquellos métodos que sean de interés para la aplicación,
porque todos los otros métodos serán resueltos por la clase Adapter
Uno de los objetos receptor que se implementan con mayor frecuencia son los de
la interfaz WindowListener en el manejo de ventanas, lo que haría necesario
sobrescribir los seis métodos de la interfaz. Por lo que la otra clase receptor que
se extiende es la clase WindowAdapter en vez de implementar la interfaz
WindowListener. La claseWindowAdapter sobrescribe los seis métodos de la
interfaz con métodos vacíos, por lo que la clase receptor no necesita sobrescribir
esos seis métodos solo el que necesita.

Gestión de Eventos
El paquete java.awt.event es el que contiene la mayor parte de las clases e
interfaces de eventos. El modelo de delegación de eventos es un concepto que
trabaja de la siguiente manera:
Una fuente genera un evento y lo envía a uno a más oyentes o auditores, que han
estado simplemente esperando hasta que reciben ese evento y una vez recibido lo
procesan y lo devuelven.
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.
Una fuente tiene que ir acompañada de auditores para que estos reciban las
notificaciones sobre el 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)
 7

Por ejemplo el método que registra o acompaña a un auditor de evento de teclado

es addKeyListener( ). Cuando ocurre un evento, se notifica a todos los auditores
registrados, que reciben una copia del objeto evento. Esto es lo que se conoce
como multicasting del evento.
Una fuente también puede proporcionar un método que permita a un auditor
eliminar un registro en un tipo específico de evento y la forma general es:
Public void removeTypeListener(TypeListener el);
Aquí Type es el nombre del evento y él es una referencia al auditor. Por ejemplo
para borrar un auditor del teclado se llamaría removeKeyListener( ).

Auditores de eventos.
Un auditor es un objeto que es avisado cuando ocurre un evento. Tiene dos
requisitos principales. Primero tiene que ser registrado o ir acompañado por una o
más fuentes para recibir notificaciones sobre los tipos específicos de eventos.
Segundo, tiene que implementar métodos para recibir y procesar notificaciones.

Clases de eventos principales en Descripción

java.awt.event Clase de 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 tipo
menú.
AdjustmentEvent Se genera cuando se manipula un
scrollbar.
ComponentEvent Se genera cuando un componente
se oculta, se mueve, se cambia de
tamaño o se hace visible.
ContainerEvent Se genera cuando se añade o se
elimina un componente de un
contenedor.
FocusEvent Se genera cuando un componente
gana o pierde el foco.
InputEvent Superclase abstracta de cualquier
clase de evento de entrada de
componente.
ItemEvent Se genera cuando se hace clic en un
checkbox o en un elemento de una
lista; también ocurre cuando se hace
una selección en una opción choice
o cuando se selecciona o
deselecciona un elemento de un
menú de opciones.
 8

KeyEvent Se genera cuando se recibe una

entrada desde el teclado.
MouseEvent Se genera cuando el ratón se
arrastra, se mueve, se hace clic, se
presiona, o se libera; también se
genera cuando el ratón entra o sale
de un componente.
TextEvent Se genera cuando se cambia el valor
de un área de texto o un campo de
texto
WindowEvent Se genera cuando una ventana se
activa, se cierra, se desactiva, se
minimiza, se maximiza, se abre, o se
sale de ella.

Adaptadores
Muchos interfaces EventListener están diseñados para recibir múltiples clases de
eventos, por ejemplo, el interfaz MouseListener puede recibir eventos de
pulsación de botón, al soltar el botón, a la recepción del cursor, etc. El interfaz
declara un método para cada uno de estos subtipos. Cuando se implementa un
interfaz, es necesario redefinir todos los métodos que se declaran en ese interfaz,
incluso aunque se haga con métodos vacíos. En la mayoría de las ocasiones, no
es necesario redefinir todos los métodos declarados en el interfaz porque no son
útiles para la aplicación.
Por ello, el AWT proporciona un conjunto de clases abstractas adaptadores
(Adapter) que coinciden con las interfaces. Cada clase adaptador implementa un
interfaz y redefine todos los métodos declarados por el interfaz con métodos
vacíos, con lo cual se satisface ya el requerimiento de la redefinición de todos los
métodos.
Se pueden definir clases Receptor extendiendo clases adaptadores, en vez de
implementar el interfaz receptor correspondiente. Esto proporciona libertad al
programador para redefinir solamente aquellos métodos del interfaz que
intervienen en la aplicación que desarrolla.
De nuevo, hay que recordar que todos los métodos declarados en un interfaz
corresponden a los tipos de eventos individuales de la clase de eventos
correspondiente, y que el objeto Fuente notifica al Receptor la ocurrencia de un
evento de un tipo determinado invocando al método redefinido del interfaz.

Las clases Adaptadores que se definen en el JDK 1.2 son las que se
indican a continuación:
java.awt.ComponentAdapter
 9

java.awt.FocusAdapter
java.awt.KeyAdapter
java.awt.MouseAdapter
java.awt.MouseMotionAdapter
 10

java.awt.WindowAdapter
 11

Interfaces de auditor que más se utilizan

ActionListener
La interfaz tiene que definir el método:
void actionPerformed(ActionEvent e) el cual se invoca cuando ocurre un evento de
acción.
AdjustmentListener
La interfaz tiene que definir el método:
void adjustmentValueChanged(AdjustmetEvent ae) el cual se invoca cuando
ocurre un evento de ajuste.
ComponentListener
La interfaz tiene que definir los siguientes métodos:
void componentResized(ComponentEvent ce)
void componentMoved(ComponentEvent ce)
void componentShown(ComponentEvent ce)
void componentHiden(ComponentEvent ce)
Se invocan cuando a un componente se le cambia de tamaño, se mueve, se
muestra o se oculta.

ContainerListener
La interfaz tiene que definir los siguientes métodos:
void componentAdded(ContainerEvet ce)
void componentRemoved(ContainerEvet ce)
Se invocan cuando se añade un componente a un contenedor y cuando se borra
un componente de un contenedor.
FocusListener
La interfaz tiene que definir los siguientes métodos:
void focusGained(FocusEvent fe)
void focusLost(FocusEvent fe)
Se invocan cuando se gana el foco o se pierde el foco
ItemListener
La interfaz tiene que definir el siguiente método:
void itemStateChanged(ItemEvent ie)
Se invoca cuando cambia el estado de un elemento
KeyListener
La interfaz tiene que definir los siguientes métodos:
void keyPressed(KeyEvent ke)
void keyReleased(KeyEvent ke)
void keyTyped(KeyEvent ke)
 12

Se invocan cuando se presiona, libera una tecla y cuando se introduce un

carácter.

MouseListener
La interfaz tiene que definir los siguientes métodos:
void mouseClicked(MouseEvent me)
void mouseEntered(MouseEvent me)
void mouseExited(MouseEvent me)
void mousePressed(MouseEvent me)
void mouseReleased(MouseEvent me)
Se invocan cuando se presiona, cuando entra a un componente, cuando sale,
cuando se presiona y se libera el ratón.
MouseMotionListener
La interfaz tiene que definir los siguientes métodos:
void mouseDragged(MouseEvent me)
void mouseMoved(MouseEvent me)
Se invocan cuando se arrastra y se mueve el ratón.
TextListener
La interfaz tiene que definir el siguiente método:
void textChanged(TextEvent te)
Se invoca cuando ha ocurrido un cambio en un área de texto o en un campo de
texto.
WindowListener
La interfaz tiene que definir los siguientes métodos:
void windowActivated(WindowEvent we) activa
void windowDeactivated(WindowEvent we) desactiva
 13

void windowClosed(WindowEvent we) Cierra

void windowClosing(WindowEvent we) petition de cerrar
void windowDeiconfied(WindowEvent we)
void windowIconfied(WindowEvent we) minimiza
void windowOpened(WindowEvent we) abre

Se invocan cuando se activa, se desactiva, se cierra una ventana, se esta

cerrando una ventana, se minimiza a un icono, cuando se abre a partir de un icono
y cuando se abre una ventana.

Clases adaptadoras que se usan Interfaz auditora

cuando no se requieren definir todos
los eventos de un elemento y son:
Clase Adaptadora
ComponentAdapter ComponentListen
ContainerAdapter ContainerListen
FocusAdapter FocusListener
KeyAdapter KeyListener
MouseAdapter MouseListener
MouseMotionAdapter MouseMotionListener
WindowAdapter WindowListener
 14

CONCLUSIÓN:
En esta pequeña introducción a la programación dirigida por eventos hemos
hecho una recopilación de pequeñas bases sobre la programación orientada a
eventos lo cual incluye el manejo de eventos y sus tipos de eventos ya que son
varios o son dependiendo de su función que se desde asimilar ya que su
programación es basa a eventos.
Esta investigación sirvió de mucho puesto que al ser ingeniero en sistemas las
bases que visualice son una nueva ventaja a la hora de programar ya que los
eventos también son importantes a la hora de crear una aplicación java en este
caso.

BIBLIOGRAFÍA:
 https://larevistainformatica.com/Lenguajes-programacion-orientado-eventos

 https://programarjava.wordpress.com/2011/12/13/programacion-orientada-a-
eventos/

 https://sites.google.com/site/topicosavprog/unidad-i-eventos

 Grant Palmer: Java Event Handling, Prentice Hall, ISBN 0-13-041802-1.

 David Luckham: The Power of Events - An Introduction to Complex Event

Processing in Distributed Enterprise Systems, Addison-Wesley, ISBN 0-201-72789-
7.
 15

PUNTO 2

EJEMPLO DE INTERACCION DE ALICACIÓN

NOMBRE: MEGADOWLOADER

Esta aplicación actua con los siguientes eventos:

ActionEvent puesto que como toda aplicación tiene botones, estos se disparan al momento de dar
clic o doble clic en el elemnto.

KeyEvent: este ocurre cuando se le cambia el nombre del archivo que se descrgara, este evento se
da a la entrada del teclado.

textEvent: esete evnto ocurre cuando se cambia el valor de un area de texto, en la aplicación
ocurre cuando el usuario cambia de direccion de almacenamiento de la descarga

MouseEvent:este evento ocurre cuando se selecciona una descarga ya sea en cuerso o ya

completada.

AdjustmenEvent: este ocurre cuando manipulas el scrollbar de la aplicación para subir y bajar

WindowEvent: Se genera cuando una ventana se activa, se cierra, se desactiva, se minimiza, se

maximiza, se abre, o se sale de ella.