Download semana 7 - IACC PES

PROGRAMACIÓN WEB I
SEMANA 7
ESTE DOCUMENTO CONTIENE LA SEMANA 7
1
ÍNDICE
MANEJO DE EVENTOS EN JAVA ..................................................................................................... 3
INTRODUCCIÓN ............................................................................................................................. 3
APRENDIZAJES ESPERADOS ........................................................................................................... 3
MANEJO DE EVENTOS EN JAVA (AWT y SWING)........................................................................... 4
CONCEPTOS BÁSICOS EN EL MANEJO DE EVENTOS ...................................................................... 4
MECANISMO PARA EL MANEJO DE EVENTOS ............................................................................... 6
ACCIONES PARA PROCESAR UN EVENTO ...................................................................................... 7
PASOS PARA LA DEFINICIÓN DE GUI CON SWING ........................................................................ 7
PRIMERA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA .................................................... 8
EVENTOS DE TECLADO .............................................................................................................. 8
EVENTOS DE RATÓN .................................................................................................................. 8
EVENTOS DE BARRAS ................................................................................................................ 9
EVENTOS DE LISTA..................................................................................................................... 9
EVENTOS DE VENTANA ............................................................................................................. 9
EVENTOS VARIOS ...................................................................................................................... 9
SEGUNDA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA................................................. 10
EVENTOS GENERALES .............................................................................................................. 10
EVENTOS ESPECÍFICOS ............................................................................................................ 10
TERCERA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA .................................................. 14
EVENTOS DE BAJO NIVEL......................................................................................................... 14
EVENTOS DE ALTO NIVEL ........................................................................................................ 15
LAS CLASES DE ESCUCHA ............................................................................................................. 15
EJEMPLO DE PROGRAMACIÓN .................................................................................................... 17
COMENTARIOS FINALES .............................................................................................................. 18
BIBLIOGRAFÍA .............................................................................................................................. 19
ESTE DOCUMENTO CONTIENE LA SEMANA 7
2
MANEJO DE EVENTOS EN JAVA
INTRODUCCIÓN
En esta semana ahondaremos en la forma en que Java maneja los eventos producidos en la
ejecución de un programa basado en interfaces GUI. Para ello, definiremos algunos conceptos
básicos y revisaremos el mecanismo utilizado y las acciones necesarias para manejar y
procesar los mencionados eventos. Así mismo, esbozaremos una pequeña guía para la
definición de interfaces GUI con SWING.
Nos ocuparemos en forma amplia de las tres clasificaciones, las más utilizadas, acerca de los
tipos de eventos posibles de determinar en Java. Los elementos constitutivos de dichas tres
clasificaciones serán abordadas en profundidad, incluidas tablas y ejemplos, con el objetivo de
ampliar nuestro conocimiento de ellas.
APRENDIZAJES ESPERADOS
Se espera que, al final de esta clase, el alumno sea capaz de reconocer y clasificar los eventos
más comunes del lenguaje Java por medio de la visualización de interfaces gráficas de usuario.
Además, debe ser capaz de ilustrar la aplicación de eventos en Java a través de la
interpretación del código de programación respectivo.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
3
MANEJO DE EVENTOS EN JAVA (AWT Y SWING)
Como se ha visto en semanas anteriores, los eventos en Java se relacionan, en tanto lenguaje
orientado a objetos, con dos componentes fundamentales del lenguaje: AWT y Swing.
De ellos, a modo de resumen, podemos mencionar sus características principales.
AWT




Constituye la primera librería gráfica de este lenguaje.
Utiliza llamadas a sistemas nativos de ventanas, también llamados componentes
pesados.
Es un intento por establecer una interfaz de programación de aplicaciones (API)
genérica, aplicable a todos los sistemas de ventanas.
Sus principales problemas fueron que carecía de una gran cantidad de componentes y
las aplicaciones generadas dependían en gran medida del sistema operativo sobre el
cual se trabajara y de su entorno o sistema de ventanas.
SWING




Es la evolución natural de AWT con la cual se integra de manera transparente.
Utiliza código nativo de Java para dibujar sobre ventanas provistas por el sistema de
ventanas de la plataforma en cual se despliega. Se conoce esta facilidad como
componentes ligeros.
Es propietario de una gran cantidad de componentes.
Uniforma las aplicaciones gráficas en lo que respecta a entornos de ventanas y manejo
de componentes y eventos.
CONCEPTOS BÁSICOS EN EL MANEJO DE EVENTOS
Se sabe ciertamente que en Java cualquier evento es representado a través de objetos
específicos. Un evento ocurre siempre que un usuario interactúa con una aplicación, lo que —a
su vez— produce un efecto dentro del programa y este responde mostrando una reacción,
ejecutando una acción determinada o realizando una tarea específica. Los eventos en Java son
interpretados y ejecutados a través de JVM (Java Virtual Machine).
Ejemplos de ello son:



Hacer clic en un botón de una ventana.
Arrastrar un elemento o seleccionar un texto con el mouse.
Aprobar una tarea presionando la tecla Enter o Intro.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
4
Comprender cómo dicha interacción se produce internamente es fundamental para realizar
una adecuada programación en una GUI. Gráficamente se puede concebir esto de la siguiente
manera:
Fuente: http://www.slideshare.net/catrachito/swing2-3155722
Los encargados de generar eventos específicos en Java son precisamente AWT y Swing. Antes
de seguir adelante, se debe puntualizar que para cada uno de los generadores de eventos, a
saber AWT y Swing, existe en el lenguaje Java su respectivo paquete manejador de eventos.
Así, se tiene que sus componentes específicos o paquetes para manejo de eventos son:
AWT
Swing


java.awt.AWTEvent
javax.swing.event
ESTE DOCUMENTO CONTIENE LA SEMANA 7
5
MECANISMO PARA EL MANEJO DE EVENTOS
Ahondando un poco más en el mecanismo para manejo de eventos de este lenguaje, se tiene
el siguiente esquema, que representa los elementos que intervienen en él y sus características.
Un evento y la reacción que se gatilla ante él tiene los tres siguientes componentes claves:
a)
b)
c)
El EventSource (o sea, la fuente de un evento o el evento mismo).
El EventObject (objeto que maneja el evento producido).
El Event Listener (es quien “escucha” el evento y ejecuta el método apropiado
para este).
Fuente: www.dsi.fceia.unr.edu.ar/downloads/informatica/info_III/eventos.ppt
1) La fuente del evento o el Evento (event source)
– Este es el componente GUI, a través del cual interactúa el usuario con el
programa.
– Se comprueba que la información acerca de un evento se encuentra
encapsulada.
– El evento se deriva desde java.util.EventObject hacia java.awt.AWTEvent.
– Para fuentes diferentes de eventos diferentes, se comprueban tipos de
eventos diferentes.
– Diferentes fuentes de eventos producen diferentes tipos de eventos, por
ejemplo:
• ActionEvent es enviado por un botón.
• WindowEvent es enviado por una ventana.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
6
2) El objeto evento (event object)
– El objeto evento contiene la información del evento ocurrido.
– Este también incluye la información necesaria para manejar el evento por
parte del que escucha.
– Al momento de ocurrir un evento, el objeto evento se lo envía a los
escuchadores registrados para dicho evento.
3) El que escucha el evento (event listener)
– Es quien implementa una interface especial y determinada para un evento.
– Determina cual es la reacción específica a realizar ante un evento en
particular.
ACCIONES PARA PROCESAR UN EVENTO
Al momento de procesar eventos en una aplicación, es necesario realizar primordialmente dos
acciones:
1. Se debe registrar un event listener para cada uno de los componentes GUI, que se
espera puedan generar un evento. Este es un objeto correspondiente a aquella clase
que debe implementar todas las interfaces, una o más, del tipo event listener de los
paquetes de java.awt.event y de java.swing.event.
2. Se debe implementar un método específico o más para manejar el o los eventos,
llamados event handler, el que debe estar en concordancia con el tipo de evento que
se gatilla.
PASOS PARA LA DEFINICIÓN DE GUI CON SWING
En Swing, por su parte, los pasos a seguir para definir GUI o Intefaces Gráficas de Usuario, a
través de los cuales se generarán los eventos, son los siguientes:
1. Se deben crear primeramente los componentes.
2. En segundo lugar, para cada componente, se definirán sus propiedades.
3. Luego, se deberán crear los contenedores encargados de almacenar los componentes
creados en el paso 1.
4. Con el objeto de colocar los componentes creados en el paso 1 en los contenedores
del paso 3 se deben especificar los LayoutManagers.
5. Una vez hecho lo anterior, se añadirán los mencionados componentes en sus
contenedores.
6. A continuación se deberá definir el escucha de cada evento o event listener.
7. Finalmente, se está en condiciones de poder mostrar la GUI creada al usuario.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
7
El comportamiento de los componentes aquí mencionados es el siguiente: cada componente
gatilla un event handler o manejador, en función del tipo de evento específico que ha
sucedido. Cada componente puede registrar uno o más manejadores encargados de manejar
eventos del mismo tipo. A su vez y en forma recíproca, cada evento puede ser atendido por
uno o más manejadores.
PRIMERA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA
Una de las clasificaciones de los tipos de eventos en Java es a través del elemento que los
genera, mirado desde el punto de vista del usuario del programa. Así, esta clasificación se
puede concebir de la siguiente forma:
a)
b)
c)
d)
e)
f)
Eventos de Teclado
Eventos de Ratón
Eventos de Barras
Eventos de Lista
Eventos de Ventana
Eventos Varios
Cada uno de ellos genera respuestas específicas, ante la aplicación de acciones de diferentes
elementos activos en la interface GUI de una aplicación. Su explicación y componentes se
muestran a continuación.
EVENTOS DE TECLADO
Son aquellos que se generan como respuesta a una acción (pulsar y soltar) del usuario,
mientras el foco de entrada lo tiene un Componente.
EVENTOS DE RATÓN
Son aquellos que se generan como respuesta a acciones ejecutadas sobre el mouse, estando
este dentro de las coordenadas de un Componente.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
8
EVENTOS DE BARRAS
Son aquellos que se generan como una respuesta a la acción realizada por el usuario sobre
scrollbars o barras de desplazamiento en alguna ventana de la aplicación.
EVENTOS DE LISTA
Son aquellos que se generan al realizar la selección de algún elemento existente en una lista.
EVENTOS DE VENTANA
Son aquellos generados como una respuesta a algún cambio en un frame, ventana o diálogo.
EVENTOS VARIOS
Son aquellos que se generan como respuesta a acciones diversas ejecutadas por parte del
usuario.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
9
Cada uno de estos tipos de eventos se pueden reflejar, a su vez y hablando en forma práctica,
en una interfaz GUI con la cual interactúe el usuario en el manejo de un programa o aplicación.
Por ejemplo:
Fuente: www.dsi.fceia.unr.edu.ar/downloads/informatica/info_III/eventos.ppt
SEGUNDA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA
Como ya se ha dicho en forma reiterada, los eventos son los que permiten a una aplicación
realizar una interacción fluida con los usuarios. A grandes rasgos, Java distingue dos tipos de
eventos: los eventos genéricos, generales o simples y los eventos específicos.
EVENTOS GENERALES
Los eventos generales o simples son aquellos producidos por una acción de tipo general.
También son llamados eventos estándares.
EVENTOS ESPECÍFICOS
Los eventos específicos son aquellos que se generan a partir de una acción única e inequívoca
a partir de una GUI. Ellos indican de manera específica el componente a partir del cual se ha
generado un evento.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
10
A continuación, se exponen diversas tablas que ilustran aquellos eventos posibles de observar
y el método asociado a cada uno de ellos.
Eventos estándares de teclado y de ratón
Eventos generados por Componentes específicos (1)
ESTE DOCUMENTO CONTIENE LA SEMANA 7
11
Eventos generados por Componentes específicos (2)
Los dos tipos de eventos, recién presentados, se instancian a partir de la clase java.awt.event y
para programarlos, cuando se trata de manejar eventos, existen dos opciones:
1. Construir un manejador de eventos en forma detallada, a través de la implementación
de un método llamado handleEvent(), por ejemplo:
ESTE DOCUMENTO CONTIENE LA SEMANA 7
12
2. Pasar los eventos generados a un método llamado action().
Un método action() en general tiene la siguiente estructura:
Un ejemplo de implementación se muestra a continuación:
ESTE DOCUMENTO CONTIENE LA SEMANA 7
13
TERCERA CLASIFICACIÓN DE LOS TIPOS DE EVENTOS EN JAVA
Una tercera clasificación de los tipos de eventos posibles de capturar en Java está dada por los
llamados eventos de bajo y de alto nivel.
EVENTOS DE BAJO NIVEL
Son los más comunes y ya se han visto en otras clasificaciones, son producidos por el usuario
de una aplicación con acciones como pulsar una tecla, efectuar movimientos del cursor con el
ratón o visualizar componentes en pantalla. Las clases asociadas a este tipo de eventos se ven
en la siguiente tabla:
Se muestran, a continuación, los métodos definidos para KeyEvent y MouseEvent.
KeyEvent
MouseEvent
ESTE DOCUMENTO CONTIENE LA SEMANA 7
14
EVENTOS DE ALTO NIVEL
Los eventos de alto nivel se relacionan directamente con los componentes y su semántica. Se
generan típicamente al momento de pulsar un botón sobre una GUI o cuando un texto
contenido en un campo de ese tipo es modificado. Sus clases asociadas son:
LAS CLASES DE ESCUCHA
Las clases de escucha o Listeners son proporcionadas por Java para realizar la función de
captura de los eventos, tanto de bajo como de alto nivel. Cada tipo de evento existente en Java
cuenta con su propia clase de escucha o interface. Estas, dependiendo del evento que se haya
producido y capturado, ejecutarán el conjunto de métodos contenidos en la declaración de la
clase de escucha respectiva.
Se muestra, a continuación, una tabla de las clases de escucha de Java y los métodos
correspondientes a cada una de ellas.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
15
ESTE DOCUMENTO CONTIENE LA SEMANA 7
16
EJEMPLO DE PROGRAMACIÓN
En el programa anterior las acciones definidas son:



Agregar una respuesta para cerrar una ventana.
Agregar a la ventana un botón y adaptar su tamaño al del botón.
El botón se hace receptivo al mouse, respondiendo con la impresión de una línea de
caracteres en la consola.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
17
COMENTARIOS FINALES
Hemos visto la manera en que Java maneja los eventos producidos en la ejecución de un
programa basado en interfaces GUI, a través de la activación por parte del usuario de
dispositivos de entrada tales como el ratón o el teclado. Los efectos producidos en un
programa, de esta forma, gatillan su reacción ejecutándose tareas específicas por parte de
este. Java Virtual Machine es la encargada de la generación de dichos eventos. El mecanismo
involucrado en esta reacción consta de tres componentes: EventSource, EventObject y
EventListener. Las acciones necesarias para procesar un evento pasan por registrar un eventlistener e implementar uno o más métodos específicos para responder a ellos, es el llamado
event-handler.
Por otra parte, existen, al menos, tres clasificaciones de los tipos de eventos producidos en
Java. La primera de ellas incluye tanto el hardware a través del cual se ha gatillado el evento,
teclado o ratón, como también los componentes de una aplicación GUI, que reciben los
estímulos necesarios para generar una reacción al interior de la misma, tales como ventanas,
barras de desplazamiento, etcétera. La segunda clasificación nos habla de eventos generales y
específicos, pero siempre dentro del contexto de cuál es el elemento que gatilla un
determinado evento. La tercera clasificación de eventos en Java, por su parte, los diferencia
entre eventos de bajo nivel y de alto nivel. Los primeros se refieren a aquellos eventos
generados por el usuario a través del hardware, de nuevo teclado y ratón, y los segundos son
los que la interfaz gráfica capta por medio de la modificación de algún componente del
software o de la acción directa del usuario sobre alguno de estos componentes.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
18
BIBLIOGRAFÍA
Gómez López, J. (2011). Administración de Sistemas Operativos. Un enfoque práctico. 2ª
Edición. Madrid, España: RA-MA Librería y Editorial Microin.
Holzer, S. (2000). La Biblia de Java 2. Madrid, España: Anaya Multimedia.
Patrick, N. & Herbert, S. (2000). Java, Manual de Referencia. Madrid: McGraw-Hill.
Sánchez, J. (2005). Programación en Java 2. Madrid, España: McGraw-Hill.
Schildt, H. (2003). Manual de Referencia Java 2. Madrid, España: McGraw-Hill.
ESTE DOCUMENTO CONTIENE LA SEMANA 7
19