Creación y jerarquía de eventos

Una de las principales funciones de los programas, es darle respuesta al usuario cuando efectúa ciertas acciones como:

• Presionar un botón.
• Seleccionar un elemento.
• Mover el ratón.

Para llevar estas acciones, puedes emplear los eventos.

Un usuario, al interactuar con su equipo, lo hace a través de la interfaz gráfica de un programa. Esta interfaz puede ser:

• Un botón.
• Selectores.
• Campos de entrada o texto.
• Otros.

Cuando el usuario realiza alguna de estas acciones, el programa internamente llama a un método, el cual efectúa cierta lógica de programación que puede o no, otorgar una respuesta al usuario. En Java, a esto se le conoce como evento.

La dinámica de trabajo con un evento inicia con el objeto fuente, pero éste no actúa, sino que delega la acción al objeto oyente, que es el encargado de aplicar la lógica de programación correspondiente.

Según la acción que realice el usuario y el tipo de componente que se esté utilizando, el sistema puede devolver uno o más eventos.

El objeto fuente genera el o los eventos y el objeto oyente se encarga de gestionarlos.

Los eventos se pueden clasificar en dos tipos:

Existen varias formas de implementar un evento en Java, con éstas, puedes conocer qué acciones realizan los usuarios sobre las aplicaciones.

La mayoría de las interfaces que Java proporciona están diseñadas para responder a varios tipos de eventos, para ello, cuentan con más de un método.

Revisa el siguiente ejemplo:

Cuando trabajas con este tipo de interfaces, necesariamente llamas a todos sus métodos, aunque no los requieras, por lo que se quedarán varios los que no ocupes.

class EventMouse implements MouseInputListener {

    @override
    public void mouseClicked(MouseEvent e) {}

    @override
    public void mousePressed(MouseEvent e) {}

    @override
    public void mouseReleased(MouseEvent e) {}

    @override
    public void mouseEntered(MouseEvent e) {}

    @override
    public void mouseExited(MouseEvent e) {}

    @override
    public void mouseDragged(MouseEvent e) {}

    @override
    public void mouseMoved(MouseEvent e) {}
}

public class adapterMouse extends MouseInputAdapter{

    @override
    public void mouseClicked(mouseEvent e) {
        // code
    }

}

Para que apliques los eventos a los diferentes elementos de la interfaz en este programa, agrega esos eventos a través de alguno de los métodos que provee Java.

boton.addActionListener(new ActionListener() {
    
    @override
    public void actionPerformed(ActionEvent ae) {
        // código
    }
});

Existen tres formas con las que puedes agregar eventos a los diferentes elementos de una interfaz, estos son:

• Clase anónima.
• Clase anidada.
• Implementación de Listener en clase.

Es la que se puede implementar sin asignarle un nombre, por lo que no vuelve a ser referenciada.

La sintaxis para su creación es:

new NombreClaseAnonima() {
    /* Definición de la clase anónima */
}

Estas clases son utilizadas cuando se necesita clases ligeras que funcionen como parámetros y, por lo general, implementan una interfaz.

JButton button = new JButton("Botón");
button.addActionListener(new ActionListener() {
    @override
    public void actionPerformed(ActionEvent ae) {
        // método que se ejecutará cuando se presione el botón
    }
});

Se tiene un botón al que se le agregó un evento mediante el método addActionListener; como argumento recibe una clase anónima, la cual se encarga de ejecutar el evento cuando se presiona el botón.

Es la que se define como miembro de otra. Esto se hace con el propósito de agrupar clases que solo serán utilizadas dentro de una clase.

La forma para declararlas es la siguiente:

public class ClasePrincipal {
    // Código de la clase principal

    private class claseAnidada {
        // Código de la clase anidada
    }
}

Observa que en el siguiente ejemplo se agregó una clase anidada, la cual controlará el evento del botón.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class EventButton extends Frame {
    EventButton() {
        // Métodos básicos para la creación de una ventana, los provee la clase JFrame
        setTitle("Evento del botón");
        setSize(500,500);
        setLayout(null);
        
        // Creación y ubicación del botón
        JButton button = new Button("Presionar");
        button.setBounds(100, 100, 100, 50);

        // Instancia de la clase anidada y evento relacionado con el botón creado
        EventButtonListener eventButtonListener = new EventButtonListener();
        button.addActionListener(eventButtonListener);

        // Agrega el botón a la ventana
        getContentPane().add(button);

        // Métodos básicos para la creación de una ventana, los provee la clase JFrame
        setVisible(true);
    }

    // Método principal de ejecución
    public static void main(String[] args) {
        EventButton e = new EventButton();
    }

    // Instancia de la clase anidada y evento relacionado con el botón creado
    public class EventButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("actionPerformed");
        }
    }
}

Otra forma de implementar interfaces para el registro de eventos es usar la misma clase, pero como Listener.

public class NombreClase implements NombreInterfaz {

    @Override
    public void actionPerformed(ActionEvent e) {
        // código
    }
}

El trabajar de esta manera, implica que los métodos a sobrescribir queden en el mismo nivel que el resto del código.

Debido a esto, no es una opción muy recomendable, ya que la capa de presentación y lógica terminan combinándose dentro de la misma clase.

En este ejemplo la funcionalidad del botón se encuentra sobre la misma clase.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.swing.JButton;
import java.swing.JFrame;

public class EventButton extends JFrame implements ActionListener {
    EventButon() {
        // Métodos básicos para la creación de una ventana, los provee la clase JFrame
        setTitle("Evento del botón");
        setSize(500,500);
        setLayout(null);
        
        // Creación y ubicación del botón
        JButton button = new Button("Presionar");
        button.setBounds(100, 100, 100, 50);
        
        // evento relacionado con el botón
        button.addActionListener(this);

        // Agrega el botón a la ventana
        getContentPane().add(button);

        // Métodos básicos para la creación de una ventana, los provee la clase JFrame
        setVisible(true);
    }

    // Método principal de ejecución
    public static void main(String[] args) {
        EventButton e = new EventButton();
    }

    // evento relacionado con el botón
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("actionPerformed");
    }
}