Creación de eventos
desde código
La ventana de diseño
de NetBeans nos permite crear cada componente, colocarlo en la ventana y
acceder a los eventos que necesitemos fácilmente para programar en ellos las
acciones que se tengan que realizar.
Sin embargo, si el
diseño de la ventana se ha realizado directamente desde código, será necesario
crear también desde código los distintos eventos a usar, y asociarlos al
componente correspondiente.
Para programar
eventos hay que tener en cuenta lo siguiente:
-
Un evento pertenece
a un objeto “Oyente” (Listener) o a un objeto “Adaptador” (Adapter)
-
El objeto
oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento.
Por ejemplo:
Programar la pulsación de un botón btnSumar.
La pulsación de un
botón es un evento actionPerformed
como ya se sabe.
El evento actionPerformed pertenece a un
objeto llamado ActionListener.
El objeto ActionListener es lo que se denomina un oyente.
El objeto ActionListener se asociará al
botón btnSumar
Programación de eventos
La programación de
eventos es compleja, ya que cada evento pertenece a un oyente/adaptador, y a su
vez, hay que asociar cada oyente/adaptador al componente que responde al
evento.
Por otro lado, la
sintaxis de programación para los eventos es distinta a lo que se ha visto
hasta ahora, por lo que puede resultar bastante oscura, aunque por otro lado,
siempre sigue el mismo patrón.
Para simplificar el
estudio de la programación de eventos, nos limitaremos a los eventos más
usados, los cuales pueden clasificarse en los siguientes grupos:
-
Eventos de Acción:
o
actionPerformed
§ Activar un componente (pulsación de botón, enter en un cuadro de
texto)
-
Eventos de Teclado:
o
keyPressed
§ Se pulsó una tecla, pero no se soltó.
o
keyReleased
§ Se soltó una tecla.
o
keyTyped
§ Se pulsó y soltó una tecla.
-
Eventos de Ratón:
o
mousePressed
§ Se pulsó un botón del ratón.
o
mouseReleased
§ Se soltó un botón del ratón.
o
mousePressed
§ Se pulsó y soltó un botón del ratón.
o
mouseEntered
§ El ratón entró en la superficie del control.
o
mouseExited
§ El ratón salió de la superficie del control.
-
Eventos de Ventana:
o
windowOpened
§ Se abrió la ventana
o
windowClosing
§ Se cerró la ventana
o
windowActivated
§ Se activó la ventana
o
windowDeactivated
§ Se desactivó la ventana
En esta explicación
guiada nos limitaremos a estudiar los eventos de acción.
PROGRAMACIÓN DE EVENTOS DE ACCIÓN:
Un evento de acción
hace referencia a la activación de un objeto (un botón, un cuadro de texto, un
combo, etc.).
Sólo existe un tipo
de evento de acción, llamado actionPerformed.
El evento actionPerformed pertenece a un
objeto oyente llamado ActionListener.
Eventos de Acción:
Eventos
|
|
Oyente/Adaptador
|
actionPerformed
|
Se programan dentro de...
|
ActionListener
|
La forma de
programar el evento actionPerformed
de un componente yyy es la siguiente:
yyy.addActionListener(new ActionListener() {
public void
actionPerformed(ActionEvent evt) {
yyyActionPerformed(evt);
}
});
Para entender la
sintaxis de la programación de un evento de acción, supongamos el siguiente
ejemplo:
Se quiere programar
el evento de un botón llamado btnSumar
desde código. He aquí el código para crear el evento:
btnSumar.addActionListener(new ActionListener() {
public void
actionPerformed(ActionEvent evt) {
btnSumarActionPerformed(evt);
}
});
Una explicación del
código:
El código anterior
permite crear y asignar el evento actionPerformed al botón btnSumar,
pero no programa el evento. Para programar el evento es necesario crear el
procedimiento cuya llamada se incluye dentro del evento actionPerformed:
public void btnSumarActionPerformed(ActionEvent evt) {
… aquí se programa
el evento actionPerformed del botón btnSumar …
}
A pesar de lo complicado que resulta, hay que tener en cuenta que
siempre se programa de la misma forma. Solo hay que cambiar el componente que
se quiere programar y asignar un nombre al método donde se programará el
evento.
Hay que tener en cuenta que en el código expuesto antes participan
nuevas clases como son ActionEvent y ActionListener, y se
tendrán que agregar los import correspondientes.
EJERCICIO:
- Abra el proyecto Operaciones
que se hizo en el ejercicio de la hoja anterior.
- En el ejercicio anterior se
diseñó desde código la ventana de dicho proyecto. Esta ventana tiene el
siguiente aspecto (Se indica también el nombre de los distintos
componentes):
- El objetivo del ejercicio es
programar la pulsación del botón btnSumar para que aparezca un JOptionPane
con la suma calculada. Luego haremos lo mismo con el botón btnRestar.
Todo esto se hará desde código.
- Para recordar, he aquí el código
programado hasta ahora. Tenemos una llamada desde el método constructor a
un método creacionVentana donde diseñamos cada uno de los elementos
de la ventana:
/**
* Creates new form VentanaInicial
*/
public VentanaInicial()
{
initComponents();
creacionVentana();
}
public
void creacionVentana() {
this.setTitle("Programa Operaciones");
this.setSize(500,
300);
this.setLocation(100,
100);
etiNumero1 =
new JLabel();
etiNumero1.setText("Número 1:");
etiNumero1.setBounds(10,
10, 100, 20);
this.getContentPane().add(etiNumero1);
etiNumero2
= new JLabel();
etiNumero2.setText("Número 2:");
etiNumero2.setBounds(10,
60, 100, 20);
this.getContentPane().add(etiNumero2);
txtNumero1
= new JTextField();
txtNumero1.setText("0");
txtNumero1.setBounds(110,
10, 100, 30);
this.getContentPane().add(txtNumero1);
txtNumero2
= new JTextField();
txtNumero2.setText("0");
txtNumero2.setBounds(110,
60, 100, 30);
this.getContentPane().add(txtNumero2);
btnSumar
= new JButton();
btnSumar.setText("Sumar");
btnSumar.setBounds(10,
120, 100, 30);
this.getContentPane().add(btnSumar);
btnRestar
= new JButton();
btnRestar.setText("Restar");
btnRestar.setBounds(150,
120, 100, 30);
this.getContentPane().add(btnRestar);
}
- Ahora asignaremos un evento actionPerformed
al botón btnSumar. Esto lo haremos al final del método creacionVentana,
El código que debe añadir para el evento actionPerformed del botón btnSumar es el
siguiente:
btnSumar.addActionListener(new ActionListener() {
public
void actionPerformed(ActionEvent evt) {
btnSumarActionPerformed(evt);
}
});
(Recuerda que el código es siempre igual, solo hay que indicar el
nombre del botón y el nombre del procedimiento al que se llama).
- Será necesario añadir un import
para el objeto oyente ActionListener y para la clase ActionEvent.
- Ahora que se ha definido un
evento actionPerformed para el botón btnSumar, será
necesario programarlo. Esto se hace creando el procedimiento al que llama
el código del actionPerformed.
A este procedimiento le hemos dado de nombre btnSumarActionPerformed.
Así pues, añade el siguiente procedimiento a la clase. (No te vayas
a equivocar, el siguiente código está fuera del método creacionVentana).
- Es precisamente en este nuevo
procedimiento que hemos creado donde se programa el evento actionPerformed
del botón btnSumar. Lo que se pretende que haga el programa es que
aparezca un JOptionPane con la suma de los números introducidos. Para
ello, añade el siguiente código:
- Bien, hemos programado la
pulsación del botón Sumar. Hemos seguido dos pasos:
- Primero hemos creado el evento
actionPerformed y se lo hemos asignado al botón. Esto lo
hemos hecho dentro del método creacionVentana. Este evento
hace una llamada al procedimiento donde se programará la respuesta al
evento.
- Luego hemos creado ese
procedimiento y hemos programado en él el código correspondiente a la
pulsación del botón.
Ejecuta el programa y comprueba el funcionamiento del botón Sumar.
- Ahora programaremos el botón btnRestar.
Primero se tendrá que definir el evento actionPerformed y asignárselo al botón. Esto se
hace añadiendo el código de creación del evento al final del método creacionVentana.
btnRestar.addActionListener(new ActionListener() {
public
void actionPerformed(ActionEvent evt) {
btnRestarActionPerformed(evt);
}
});
(Observa que es idéntico al código de asignación del evento del
botón btnSumar, sólo cambia el nombre del botón y el nombre del
procedimiento al que se llama).
- Y ahora, hay que programar el
procedimiento al que llama el evento actionPerformed. Es aquí donde
se programa la respuesta al evento. En nuestro ejemplo, queremos que al
pulsar el botón Restar se resten los números introducidos.
public void btnRestarActionPerformed(ActionEvent
evt) {
double num1, num2, resta;
num1 = Double.parseDouble(txtNumero1.getText());
num2 = Double.parseDouble(txtNumero2.getText());
resta = num1 - num2;
JOptionPane.showMessageDialog(null, "La resta es: " +
resta);
}
- Ejecuta el programa y comprueba
el funcionamiento del botón Restar.
- Resumiendo una vez más. Para
programar un evento sobre un componente, primero hay que enlazar el oyente
del evento con el componente, y luego programar el método al que llama el
evento. Observa el código que hemos programado:
CONCLUSIONES:
Cada evento
pertenece a un objeto oyente, y es el oyente el que se asigna al componente de
la ventana que se quiere programar.
El evento actionPerformed pertenece al oyente ActionListener.
Para enlazar el
oyente ActionListener a un componente
YYY hay que usar el siguiente código:
YYY.addActionListener(new
ActionListener() {
public
void actionPerformed(ActionEvent evt) {
YYYActionPerformed(evt);
}
});
El enlace de un
evento a un componente se hace en el método constructor. Esta asignación hace
una llamada a un procedimiento YYYActionPerformed, (donde YYY representa el
nombre del componente que se programa). Es en este procedimiento donde
realmente se programa el evento.
No hay comentarios.:
Publicar un comentario