Manipulación de eventos

Todo programa necesita ejecutar cierta funcionalidad cuando el usuario realiza una acción, ya sea, cuando presiona algún botón, mueva el mouse, etc.

Necesitamos conocer la manipulación de eventos, la cual nos permite saber:

• Que está haciendo el usuario en la aplicación.
• Qué lógica de programación se debe ejecutar.
• Mostrar con mensajes informativos que fue lo que hizo internamente la aplicación.

Entonces, la manipulación de eventos consiste en:

• Obtener las aciones que un usuario realiza sobre la interfaz gráfica de una aplicación.
• Ejecutar cierta lógica de programación para brindarle al usuario una respuesta de lo que hizo internamente el sistema.

Java nos provee de una serie de métodos con los cuales podemos detectar las acciones que un usuario realiza sobre la interfaz de la aplicación.

Veremos más a fondo algunos de ellos.

Te preguntarás:

• ¿Cómo hacer la conexión entre las clases que generan los eventos (objeto fuente) y las clases que se encargarán de gestionar los eventos (objeto oyente).
• ¿Cómo funciona algo tan sencillo, como presionar un botón?

Lo aprenderemos aquí.

La gestión de eventos se encarga de:

• Ejecutar métodos.
• Otorgar una a un usuario, lo que brinda un comportamiento más dinámico al programa.

Esta forma de trabajo es conocida como Programación basada a eventos o Programación dirigida a eventos.

La forma de tratar eventos se realiza mediante el Modelo de delegación de eventos o Event Model Delegation.

¿Cómo funciona el modelo de delegación de eventos?

• El objeto fuente registra los oyentes.
• Cuando un evento ocurre, el objeto fuente invoca un método del oyente.
• Para que esta comunicación sea posible, el objeto fuente debe enviar el evento generado al objeto oyente.

¿Qué ventajas tiene usar el modelo de delegación de eventos?

• Tener los conceptos de objeto fuente y objeto oyente.
• Nos facilita la creación de código más robusto para la gestión de eventos.
• Permite marcar una separación más precisa entre la interfaz y la lógica de programación.

Este modelo es muy versátil y fácil de ampliar, brinda la posibilidad de registrar varios objetos oyentes, y a la vez permite que varios objetos oyentes sean registrados por más de un objeto fuente.

Ya hemos hablado de como funcional los eventos y su propagación, pero aún no conocemos la forma de controlar o ejecutar la acción internamente el la aplicación.

Enseguida conoceremos cómo es este proceso.

1. Sabemos que la raíz de todos los eventos es la clase java.util.EventoObject.
2. Esta clase posee como único atributo un objeto, el cual a su vez contiene el método getSource(). Dicho método nos permite acceder al objeto para conocer que evento lo generó.
3. El resto de las clases que le proceden empiezan a añadir sus propios métodos y atributos para responder a cada tipo de acción del usuario.

A continuación se explica un ejemplo completo del uso de un evento cuando se presiona un botón y se realiza una modificación al texto inicial en la ventana.

Un objeto oyente es el que controla cuál bloque de código será ejecutado cuando se emita un evento.

Con este propósito, puede definir más de un método para gestionar la respuesta por cada tipo de evento.

Para reaccionar adecuadamente, la clase oyente recibe el evento que se genera, esto garantiza el uso de la interfaz adecuada para el procesamiento de dicho evento.

Depende de cada interfaz proporcionar los métodos correspondientes al tipo de evento.

public class ListenButton implements ActionListener {
    @Override
    public void ActionPerformed(ActionEvent e) {
        if(e.getSource() == buttonA) {
            // lógica de cuando sea presionado el botón A
        } if(e.getSource() == buttonB) {
            // lógica de cuando sea presionado el botón B
        }
    }
}

Hasta el momento solo hemos visto los eventos de la interfaz ActionListener.

Pero también existen eventos de mouse el cual contiene más de un método y es necesario conocer el orden de ejecución de cada uno de esos métodos para realizar un ejemplo de sincronización de eventos.

En las siguiente clase se pueden ver los métodos de la interfaz MouseListener.

public class EventMouse implements MouseListener {
    
    /*
    Ocurre cuando el botón termina de ser presionado
    después del método mouseReleased
    */
    @Override
    public void mouseClicked(MouseEvent e) {/*código*/}

    /*
    Ocurre cuando se está presionando el botón
    */
    @Override
    public void mousePressed(MouseEvent e) {/*código*/}

    /*
    Ocurre cuando se deja de presionar el botón
    */
    @Override
    public void mouseReleased(MouseEvent e) {/*código*/}

    /*
    Ocurre cuando el puntero entra en el botón
    */
    @Override
    public void mouseEntered(MouseEvent e) {/*código*/}

    /*
    Ocurre cuando el puntero abandona el área del botón
    */
    @Override
    public void mouseExited(MouseEvent e) {/*código*/}
}

Ahora veamos un ejemplo completo utilizando la interfaz MouseListener.

A continuación veremos cómo cada uno de los métodos de la interfaz MouseListener tiene un orden de ejecución.

Antes de ver un ejemplo utilizando la sincronización de eventos vamos a ver hilos en Java, mejor conocidos como Thread.

Para ello, primero comprenderemos como es que Java ejecuta cada línea de código.

Tenemos un método en Java que manda llamar cuatro métodos, pero estos serán ejecutados uno por uno, es decir, de forma secuencial, ejecutará todas las sentencias del método add para después continuar con las sentencias del método subtract y así con el resto de métodos.

public void basicOperations() {
    this.add();
    this.subtract();
    this.multiply();
    this.divide();
}

public double add() {/* código */}

public double subtract() {/* código */}

public double multiply() {/* código */}

public double divide() {/* código */}

Entonces, cómo habíamos comentado, en Java podemos usar hilos, los cuales nos permiten:

• Ejecutar más de un proceso.
• Esto hace que el programa se ejecute en menor tiempo y sea más eficiente.

Para este ejemplo consideramos que tenemos un procesador con cuatro núcleos, entonces el programa sería capaz de ejecutar los cuatro métodos al mismo tiempo y así cada método no estaría a la espera de que el otro termine para ser procesado.

Si durante el desarrollo de la aplicación no hacemos uso de hilos, el programa solo será capaz de ejecutar un solo proceso a la vez.

En cambio, si hacemos uso de hilos, el programa será capaz de ejecutar n cantidad de procesos. La única limitación es el número de núcleos que tiene el procesador de cada ordenador.

Para crear un hilo en Java, hacemos uso de la clase Thread.

1. Tenemos un método, el cual crea un hilo mediante la clase Thread.
2. La clase Thread contiene el método aun, el cual contiene las sentencias que serán ejecutadas en un núcleo del ordenador.
3. Para iniciar el hilo, debemos utilizar el método start de la clase Thread.
4. Utilizamos el bloque try-catch para controlar los errores, en este caso el método sleep lo solicita obligatoriamente.
5. Utilizamos el método estático sleep de la clase Thread para detener el flujo del programa por un periodo de tiempo, el parámetro que recibe corresponde al tiempo que el programa será detenido en milisegundos.
6. Se imprime en consola los valores de los parámetros en el método.

public void createThread(String message, int time) {
    new Thread() {
        @Override
        public void run() { // 2
            try{ // 4
                Thread.sleep(time); // 5
                System.out.println(message + " - " + time + " ms"); // 6
            } catch (InterruptedException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }.start(); // 3
}

La sincronización de eventos

Es la ejecución de un evento o más al mismo tiempo. Entonces, para hacer esto necesitamos implementar hilos en nuestro programa.

Anteriormente se explicaron los eventos de la interfaz MouseListener y un método para la creación de un hilo.

Ahora integraremos ambos ejemplos para hacer la sincronización de eventos.

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class EventMouse extends Jframe implements MouseListener {

    // Constructor de la clase EventMouse, donde se crea
    // la ventana, se agrega un botón y se agrega el
    // listener al botón, además de algunas configuraciones
    // básicas para la creación de una ventana en Java
    public EventMouse() {
        setTitle("Evento del botón");
        setSize(500,500);
        setLayout(null);

        JButton button = new JButton("Presionar");
        button.setBounds(100, 100, 100, 50);

        button.addMouseListener(this);

        getContentPane().add(button);

        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    // Método principal de la clase EventMouse
    public static void main(String[] args) {
        EventMouse e = new EventMouse();
    }

    // Métodos sobrescritos de la interfaz MouseListener
    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("MouseClicked");
    }

    @Override
    public void mousePressed(MouseEvent e) {
        System.out.println("MousePressed");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        System.out.println("MouseReleased");
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        System.out.println("MouseEntered");
    }

    @Override
    public void mouseExited(MouseEvent e) {
        System.out.println("MouseExited");
    }
}

public void createThread(String message, int time) {
    new Thread() {
        @Override
        public void run() {
            try {
                Thread.sleep(time);
                System.out.println(message + " - " + time + " ms");
            } catch (InterruptedException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }.start();
}

Se crea un hilo cada vez que es ejecutado un método de la interfaz MouseListener.

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class EventMouse extends Jframe implements MouseListener {

    // Constructor de la clase EventMouse, donde se crea
    // la ventana, se agrega un botón y se agrega el
    // listener al botón, además de algunas configuraciones
    // básicas para la creación de una ventana en Java
    public EventMouse() {
        setTitle("Evento del botón");
        setSize(500,500);
        setLayout(null);

        JButton button = new JButton("Presionar");
        button.setBounds(100, 100, 100, 50);

        button.addMouseListener(this);

        getContentPane().add(button);

        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setVisible(true);
    }

    // Método principal de la clase EventMouse
    public static void main(String[] args) {
        EventMouse e = new EventMouse();
    }

    // Observamos que se manda a llamar el método
    // createThread en los métodos de la
    // interfaz MouseListener
    @Override
    public void mouseClicked(MouseEvent e) {
        createThread("Hilo de mouseClicked", 500);
    }

    @Override
    public void mousePressed(MouseEvent e) {
        createThread("Hilo de mousePressed", 800);
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        createThread("Hilo de mouseReleased", 300);
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        createThread("Hilo de mouseEntered", 1200);
    }

    @Override
    public void mouseExited(MouseEvent e) {
        createThread("Hilo de mouseExited", 800);
    }

    public void createThread(String message, int time) {
        // crea un hilo cada vez que el método es llamado
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(time);
                    System.out.println(message + " - " + time + " ms");
                } catch (InterruptedException ex) {
                    System.out.println(ex.getMessage());
                }
            }
        }.start();
    }
}