Programación orientada a objetos II

Unidad 1. Eventos

Desarrollo de Software
3er Semestre

Programa de la asignatura:
Programación Orientada a Objetos II

Unidad 1. Eventos

Clave:

Ingeniería: TSU:
15142421 16142421

Universidad Abierta y a Distancia de México

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

1
Programación orientada a objetos II
Unidad 1. Eventos

Índice

Unidad 1. Eventos ............................................................................................................. 3

Presentación de la Unidad ................................................................................................. 3
Propósito ........................................................................................................................... 3
Competencia específica..................................................................................................... 3
1.1. Introducción a los eventos .......................................................................................... 4
1.1.1. Generalidades sobre los eventos ............................................................................. 4
1.1.2. Definición de eventos ............................................................................................... 5
1.2. Tipos de eventos......................................................................................................... 6
1.2.1. Eventos del ratón ..................................................................................................... 7
1.2.2. Eventos del teclado .................................................................................................. 9
1.2.3. Eventos de otros componentes .............................................................................. 12
Cierre de la Unidad .......................................................................................................... 13
Para saber más ............................................................................................................... 13
Fuentes de consulta ........................................................................................................ 14

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

2
Programación orientada a objetos II
Unidad 1. Eventos

Unidad 1. Eventos

Presentación de la Unidad

En esta primera unidad de la asignatura

Programación orientada a objetos II
(POO2) aprenderás el concepto de evento
en la programación, así como la
descripción y tipos de eventos de ratón,
teclado y de otros componentes, ya que
estos temas son importantes para la
manipulación de componentes gráficos
que se verán en la siguiente unidad.

Propósito

Al término de esta unidad lograrás:

 Identificar el concepto de eventos

en la programación.
 Identificar los eventos de ratón y
de teclado.
 Identificar el uso de eventos.
 Identificar los componentes y
estructura para el manejo de los
eventos.

Competencia específica

 Identificar los eventos en la

programación orientada a objetos
para su posterior aplicación en una
aplicación con componentes
gráficos, a través de comprender la
sintaxis que los crea.

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

3
Programación orientada a objetos II
Unidad 1. Eventos

1.1. Introducción a los eventos

Cualquier aplicación computacional requiere que los usuarios interactúen con el sistema
mediante las pantallas o interfaces gráficas de usuario (GUI) para que realicen operaciones
sobre estas, y con base en ello la aplicación pueda responder con acciones correctas para
las que fue realizada dicha aplicación, ya sea teclear datos, seleccionar respuestas o
simplemente oprimir un botón.

Por tanto, el hecho de que una aplicación responda a las operaciones que realizan los
usuarios significa que esas operaciones han sido programadas precisamente para que la
aplicación responda a cada una de las diferentes acciones que el usuario pueda llegar a
realizar.

Esas “operaciones” que los usuarios realizan son llamados eventos, y es el primer tema de
la asignatura POOII, que ayudará a realizar interfaces gráficas, utilizando el paradigma
orientado a objetos (visto en POOI) con el lenguaje JAVA.

El tema de eventos es el inicio de la asignatura

para que se comprenda su uso y manejo, que
como se verá a lo largo de esta unidad, los
eventos son componentes muy importantes
para realizar aplicaciones con componentes
gráficos, y lograr que estos proporcionen la
interacción adecuada para el usuario.
Eventos del teclado y del ratón

1.1.1. Generalidades sobre los eventos

Para comenzar este subtema es necesario que recuerdes que las interfaces gráficas de
usuario están creadas con base en elementos, tales como botones, cajas de texto,
etiquetas, etc. Estos elementos son conocidos como componentes gráficos.

Para el manejo de eventos los componentes gráficos requieren de un escuchador. El

escuchador es un elemento que está precisamente “escuchando” para detectar si la acción
realizada por el usuario (evento) es el que está asignado al componente gráfico, y deberá
reaccionar ejecutando la acción asociada a ese evento. Es decir, el escuchador solo está
esperando que algo pase, para informarlo y desencadenar una respuesta.

Un componente gráfico deberá tener tantos escuchas como eventos tenga relacionados,
porque cada uno de los escuchas deberá estar al pendiente de cada evento que pudiera
ocurrir. Por ejemplo, si se tiene un botón (componente gráfico) y se da un clic sobre él,
realiza una acción, si es una acción diferente es doble clic y si es una acción diferente a las

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

4
Programación orientada a objetos II
Unidad 1. Eventos

otras dos es clic derecho, entonces, nuestro componente botón deberá contar con 3
escuchas, uno para cada evento asociado, y evidentemente cada evento debe tener su
propio método asociado a la acción desencadenada para cada caso en particular.

Los escuchas a su vez deben tener métodos asociados que realicen las acciones
correspondientes a la respuesta que deba brindar el componente al evento asociado.

1.1.2. Definición de eventos

Un evento para una computadora básicamente es un mensaje que proporciona el

sistema operativo a un programa en ejecución, indicando que existió un suceso que
puede ser un clic de un mouse, la presión de alguna tecla en particular, o conjunto de
teclas, de esta manera, se conoce lo que el usuario está realizando.

Ahora bien, para manejar los eventos se requiere:

 Un componente sobre el que se detectará el evento requerido.
 El escuchador del evento asociado al elemento del punto anterior (para que
detecte el evento que ocurra).
 Un método que defina o redefina (según sea el caso), las acciones que deberán
realizarse al presentarse el evento.

Elementos para manejar un evento. Basada en Ceballos (2006).

Ejemplo de código de evento en un marco

package clases;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JFrame;
/**
* @author ESAD
*/
public class EjemploEventos {
public static void main (String[] args){
JFrameframe=new JFrame("Ejemplo de eventos");
frame.setLocation(100, 100);

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

5
Programación orientada a objetos II
Unidad 1. Eventos

frame.setVisible(true);
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
}
}

El ejemplo marca lo siguiente:

-En sombra azul se expone la definición de la clase, el método principal y la importación de
las librerías necesarias, así como los cierres requeridos.
-En sombra verde la declaración de un marco y sus propiedades (este tema se verá más a
fondo en la siguiente unidad, por ahora lo importante es el evento).
-En sombra morada la adición del escuchador (addWindowListener) al componente (en este
caso el marco llamado frame), que deberá precisamente escuchar los eventos que ocurran
sobre el marco; Al escuchador se le envía como parámetro la creación del adaptador
(WindowAdapter), en el adaptador se redefine el método (@Override - recuerda que la
redefinición de métodos se vio en POO1-) para cerrar la ventana (windowClosing) al
detectar dicha acción y lo que se hará es cerrar el sistema (System.exit(0);), lo cual no
sucedería normalmente con el marco.

*Nota 1: Los adaptadores (Adapter) son clases abstractas que permiten la implementación
de una interfaz (recuerda las interfaces vistas en POOI) y permite redefinir los métodos
declarados en la interfaz.

*Nota 2: Se recomienda ejecutar el ejemplo sin la sección morada y cerrar la ventana para
ver que el programa aún sigue en ejecución. Después de añadir dicha sección, se debe
volver a ejecutar la clase y con esta porción de código la aplicación finalizará al cerrar el
marco.

*Nota 3: Toma en cuenta que para poder utilizar eventos se requiere invocar el API de JAVA
awt (AbstractWindowToolkit, en español Kit de Herramientas de Ventana Abstracta), y para
el manejo de componentes gráficos se requiere el swing (biblioteca de gráficos), sin estos
componentes no podrían manejarse estos elementos.

1.2. Tipos de eventos

En este tema se abarcarán los tipos de eventos, los cuales se han dividido en tres subtemas
que son, los eventos que se generan con el ratón, con el teclado y una tercera división de
los eventos que no corresponden a los dos anteriores.

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

6
Programación orientada a objetos II
Unidad 1. Eventos

Cabe mencionar que en este material no se están dando las especificaciones de todos y
cada uno de los eventos existentes, sino de los más utilizados. Dado que cada componente
gráfico cuenta con sus propios eventos, y existen libros completos para el estudio de estos,
que en este caso solo se pretende que comprendas lo que son y cómo utilizarlos, para
conocer información especializada dirígete a la sección “Para saber más”, que se encuentra
al final de la unidad y encontrarás la liga que los creadores de Java proporcionan con todas
las especificaciones a detalle de cada evento existente.

Por ahora continúa con la presentación de los tipos de eventos.

1.2.1. Eventos del ratón

A continuación, se enlistan los tipos de eventos del ratón y el momento en el que cada uno
de ellos se detecta y se activa.

Eventos de ratón
Tipo Detección
mouseClicked Se ha hecho clic con el ratón sobre el componente. El clic
completo incluye presionar el ratón y soltarlo.
*Para detectar un doble clic se contabiliza cada clic sencillo.
mouseDragged Se ha presionado el ratón y sin soltarlo se ha arrastrado
sobre el componente.
mouseEntered El ratón se ha posicionado sobre el componente sin
presionarlo.
mouseExited El ratón deja de estar posicionado sobre el componente sin
presionarlo.
mouseMoved Se mueve el ratón sobre el componente sin presionar
mousePressed Se ha presionado el ratón sobre el componente (aun sin
soltarlo).
mouseReleased Se ha soltado (después de presionarlo) el ratón sobre el
componente.
mouseWheelmoved Se mueve la rueda del ratón sobre el componente.

Estos eventos pueden asignarse a casi todos los componentes. Es importante que al
asignar eventos a un componente, a pesar de que pueden ligarse varios al mismo
componente, es recomendable que no se asignen muchos eventos del mismo tipo para
evitar confusiones.

Por ejemplo: no deberá usarse un evento de mousePressed, mouseReleased y

mouseClicked al mismo componente y con acciones diferentes para cada uno de ellos,
debido a que un clic requiere, tanto la presión, como que se suelte el botón del ratón, porque

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

7
Programación orientada a objetos II
Unidad 1. Eventos

esto ocasionaría que exista muy poco tiempo entre cada evento y no se desplegaría
correctamente cada acción asignada.

A continuación, se muestra un ejemplo de cómo se utilizan estos eventos, observa la

siguiente clase:

Ejemplo de código 2. Evento clic en un botón

package clases;

importjava.awt.event.MouseAdapter;
importjava.awt.event.MouseEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjavax.swing.JButton;
importjavax.swing.JFrame;

/**
* @author ESAD
*/

publicclassEjemploEventoRaton {
publicstaticvoidmain (String[] args){

JButtonboton=new JButton("Oprime");
boton.setVisible(true);
boton.setSize(50, 50);
boton.setLocation(100,100);

JFrameframe=new JFrame("Ejemplo de eventos");

frame.setLocation(200, 200);
frame.setVisible(true);
frame.setSize(300, 300);
frame.add(boton);
boton.addMouseListener(new MouseAdapter() {
@Override
publicvoidmouseClicked(MouseEvent e){

System.out.print("Disteclic en el botonOprime");
}
});

frame.addWindowListener(new WindowAdapter() {
@Override

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

8
Programación orientada a objetos II
Unidad 1. Eventos

publicvoidwindowClosing(WindowEvent e){
System.exit(0);
}
});
}

El ejemplo marca:
-En azul la definición de la clase, el método principal y la importación de las librerías
necesarias, así como los cierres requeridos.
-En sombra verde la declaración de un marco y un botón, así como sus propiedades (se
verá este tema más a fondo en la siguiente unidad, por ahora lo importante es el evento).
-En sombreado morado la adición del escuchador al marco y su manipulación (que ya ha
sido explicado en el ejemplo 1).
-En sombreado naranja la adición del escuchador del ratón (addMouseListener) al botón
(llamado también boton, sin acento porque JAVA no los permite en el código), que
escuchara los eventos que ocurran con el mouse sobre el componente. Al escuchador se
le envía como parámetro la creación del adaptador (MouseAdapter), en el adaptador se
redefine el método (@Override) para detectar el evento (mouseClicked) que recibe como
parámetro un evento del tipo ratón (MouseEvent). Al ejecutar el programa se van a detectar
todos los eventos que el usuario realice, pero solo se ejecutará la acción de impresión si el
evento detectado es el indicado (mouseClicked). Si no se agrega este evento al botón éste
no realizará absolutamente nada, porque no se ha indicado que deba reaccionar ante algún
evento.

*Nota1: se recomienda ejecutar el ejemplo sin la sección naranja y hacer varios clics sobre
el botón, para ver que el programa aún sigue en ejecución sin hacer nada, y después añadir
dicha sección para volver a ejecutar la clase, y ver con esta porción de código, la aplicación
que imprimirá el mensaje colocado.

1.2.2. Eventos del teclado

A continuación, se enlistan los tipos de eventos del teclado y el momento en el que cada
uno de ellos se detecta y se activa.

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

9
Programación orientada a objetos II
Unidad 1. Eventos

Al igual que en el caso anterior no se recomienda utilizar varios eventos de teclado sobre
el mismo componente.
Ahora en el siguiente ejemplo verás cómo se utilizan estos eventos, observa la siguiente
clase:

Ejemplo de código 3. Evento de teclado en una caja de texto.

package clases;

importjava.awt.event.KeyAdapter;
importjava.awt.event.KeyEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjavax.swing.JFrame;
importjavax.swing.JTextField;

/**
* @author ESAD
*/
publicclassEjemploEventoTeclado {

publicstaticvoidmain (String[] args){

JTextFieldcajaTexto= new JTextField("Etiqueta");
cajaTexto.setVisible(true);
cajaTexto.setSize(50, 50);
cajaTexto.setLocation(100,100);

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

10
Programación orientada a objetos II
Unidad 1. Eventos

JFrameframe=new JFrame("Ejemplo de eventos");

frame.setLocation(200, 200);
frame.setVisible(true);
frame.setSize(300, 300);
frame.add(cajaTexto);
cajaTexto.addKeyListener(new KeyAdapter() {
@Override
publicvoidkeyPressed(KeyEvent e){
metodoAccion();
}
});

frame.addWindowListener(new WindowAdapter() {
@Override
publicvoidwindowClosing(WindowEvent e){
System.exit(0);
}
});
}

publicstaticvoidmetodoAccion(){
System.out.println("Mensaje");
}

El ejemplo marca:
-En azul la definición de la clase, el método principal y la importación de las librerías
necesarias, así como los cierres requeridos.

-En sombra verde la declaración de un marco y una caja de texto, así como sus propiedades
(se verá este tema más a fondo en la siguiente unidad, por ahora lo importante es el evento).

-En sombreado morado la adición del escuchador al marco y su manipulación (que ya ha

sido explicado en el ejemplo 1).

-En sombreado naranja la adición del escuchador del teclado (addKeyListener) a la caja de
texto (llamada cajaTexto) que escuchará los eventos que ocurran con el teclado sobre el
componente. Al escuchador se le envía como parámetro la creación del adaptador
(KeyAdapter), en el adaptador se redefine el método (@Override) para detectar el evento
(keyPressed) que recibe como parámetro un evento del tipo teclado (KeyEvent), se van a
detectar todos los eventos pero solo se ejecutará la acción de llamar al método

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

11
Programación orientada a objetos II
Unidad 1. Eventos

(metodoAccion), el evento detectado es el indicado (keyPressed). Si no se agrega este

evento a la caja de texto de ésta no realizará absolutamente nada, ya que no se ha indicado.

En este ejemplo puedes observar que no solo se deben colocar las acciones a realizar
dentro de la estructura de manipulación del evento, sino que también pueden realizarse
llamadas a métodos para tener un código mejor estructurado y modular.

*Nota 1: se recomienda ejecutar el ejemplo sin la sección naranja y teclear sobre la caja de
texto para ver que el programa aún sigue en ejecución sin hacer nada, y después añadir
dicha sección volver a ejecutar la clase, y ver con esta porción de código que la aplicación
imprimirá el mensaje colocado.

1.2.3. Eventos de otros componentes

Además de los eventos de ratón y teclado se presentan a continuación los tipos de

escuchadores que se pueden aplicar en donde los eventos varían de componente a
componente, por lo que solo se muestra una lista general.

Cada uno de los componentes gráficos tiene una lista de eventos predeterminados. Por
ejemplo, el código presentado en el subtema 1.1.2, es un evento de ventana (WindowEvent)

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

12
Programación orientada a objetos II
Unidad 1. Eventos

que detecta el cierre de ésta (windowClosing) y para asignarlos se utilizó el escucha de

ventanas (addWindowListener). Por consecuencia, este evento solo aplica para las
ventanas, porque son las únicas que cuentan con un elemento de cierre. Aunque, se podría
asignar un evento para detectar si se abre la ventana (windowOpened).

Para lo anterior, deberás tomar en cuenta (con base en los ejemplos), que para manipular
eventos mediante el código requieres:
 Un componente.
 Un escuchador.
 Un adaptador.
 Indicar el evento deseado a detectar.
 Tipo de evento.
 E indicar las acciones a seguir si se detecta el evento indicado.

Ahora que ya tienes los elementos necesarios para comprender los eventos, se te invita a
participar en la siguiente actividad para que pongas en práctica tus conocimientos.

Cierre de la Unidad

En el transcurso de esta unidad Eventos, observaste que por medio de ellos se identifica lo
que el usuario está realizando sobre una aplicación, y que al programar ésta responda
adecuadamente a lo que el usuario realice.

También observaste los elementos que se utilizan para manejar eventos, tales como los
escuchadores que captan los eventos, y los adaptadores que permiten la sobre escritura
de los métodos que controlarán la respuesta del programa a dichos eventos.
Finalmente identificaste los tipos de eventos que pueden detectarse, ya sea con el ratón
(como clic, doble clic, etc.), con el teclado (la presión de ciertas teclas), o con algún otro
componente (como el cierre de ventanas) y sus respectivos ejemplos con código en JAVA.

En la siguiente unidad se hablará sobre componentes gráficos, en la cual será necesario

todo lo que se ha visto en esta primera unidad, ya que es posible detectar lo que los usuarios
realizan sobre cada uno de los componentes que se revisarán en dicha unidad.

Para saber más

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

13
Programación orientada a objetos II
Unidad 1. Eventos

Es importante que instales un IDE en tu computadora personal para que pases todos los
ejemplos de código y veas cómo funcionan, de esta manera podrás analizar el
funcionamiento de los códigos presentados.

 Se recomienda que instales NetBeans 7.0, como IDE, por su facilidad de uso, éste
puede ser descargado gratuitamente de la página oficial del IDE NetBean, editor:
NetBeanscommunity, ORACLE. Recuperado de http://netbeans.org/downloads/

 Si deseas conocer los eventos asociados a cada tipo de componente, revisa la tabla
de los componentes de swing con los escuchadores que cada uno puede asociar
en los Tutoriales de Java Editor: Oracle and/oritsaffiliates, ORACLE. Esta compañía,
ofrece un amplio tutorial de programación del lenguaje JAVA, y un tema específico
sobre eventos. Recuperado de
http://docs.oracle.com/javase/tutorial/uiswing/events/eventsandcomponents.html

Fuentes de consulta

 Eckstein, R.; Loy, M. y Wood, D. (1998). JAVA Swing. California: O’Reilly.

 Ceballos, F. (2006). JAVA 2: Interfaces gráficas y aplicaciones para internet (2ª

ed.). Madrid: RA-MA.

 Oracle. (2011). The Java Tutorials. California: Oracle.

Ciencias Exactas, Ingenierías y Tecnología | Ingeniería en Desarrollo de Software

14