Ingeniería en Desarrollo de SoftwareCiencias Exactas, Ingenierías y Tecnología | Ingeniería en...

Programación orientada a objetos II Unidad 1. Eventos

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

1

Ingeniería en Desarrollo de Software

4o semestre

Programa de la asignatura:

Programación Orientada a Objetos II

Unidad 1. Eventos

Clave:

Ingeniería:

15142421

TSU:

16142421

Universidad Abierta y a Distancia de México



2

Í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 ............................................................................................................... 14

Fuentes de consulta ........................................................................................................ 14



3

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 un aplicación con

componentes gráficos, a través de

comprender la sintaxis que los crea.



4

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.

Eventos del teclado y del ratón

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

importante para realizar aplicaciones con

componentes gráficos, y lograr que estos

proporcionen la interacción adecuada para el

usuario.

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



5

las 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 1. 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);



6

frame.setVisible(true);

frame.addWindowListener(new WindowAdapter() {

@Override

public void windowClosing(WindowEvent e){

System.exit(0);

}

});

}

}

El ejemplo marca lo siguiente:

-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 sus propiedades (este tema se verá más

a fondo en la siguiente unidad, por ahora lo importante es el evento).

- En sombreado morado 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.



7

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,



8

porque 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);




frame.setSize(300, 300);

frame.add(boton);

boton.addMouseListener(new MouseAdapter() {

@Override

publicvoidmouseClicked(MouseEvent e){

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

}

});


@Override



9

publicvoidwindowClosing(WindowEvent e){

System.exit(0);

}

});

}

}

El ejemplo marca:



-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.



10

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);



11




frame.setSize(300, 300);

frame.add(cajaTexto);

cajaTexto.addKeyListener(new KeyAdapter() {

@Override

publicvoidkeyPressed(KeyEvent e){

metodoAccion();

}

});


@Override

publicvoidwindowClosing(WindowEvent e){

System.exit(0);

}

});

}

publicstaticvoidmetodoAccion(){

System.out.println("Mensaje");

}

}

El ejemplo marca:



-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



12

(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.



13

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) 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 hablara 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.



14

Para saber más

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.

http://netbeans.org/downloads/

http://docs.oracle.com/javase/tutorial/uiswing/events/eventsandcomponents.html

Ingeniería en Desarrollo de SoftwareCiencias Exactas, Ingenierías y Tecnología | Ingeniería en...

Documents

Transcript of Ingeniería en Desarrollo de SoftwareCiencias Exactas, Ingenierías y Tecnología | Ingeniería en...