Realizar una acción al pulsar un botón

Las aplicaciones han de responder a las acciones que realiza el usuario, por ejemplo: cerrar la ventana al pulsar un botón. Es necesario poder detectar las acciones de usuario y convertirlas en acciones de programa. Java dispone de varias formas de implementar este funcionamiento. En este ejercicio se mostrarán algunas de ellas. Todas se basan en este mecanismo básico:

Las Interfaces son clases "prefabricadas" con propósitos definidos. Cada Interface contiene declaraciones de métodos (nombre del método, lista de argumentos y tipo de retorno) pero estos métodos no están implementados (carecen de cuerpo); todos los métodos de las Interfaces son public. Las Interfaces también pueden declarar constantes (public final static).

En Java no existe la herencia múltiple como tal: una clase no puede heredar (extends) de más de una clase. Pero una clase puede implementar más de una Interface, ésta es una manera de tener herencia múltiple. En la clase que implementa una Interface han de ser sobrescritos (override) todos los métodos declarados en la Interface. La clase que implementa una Interface es la Interface.

ActionListener es una Interface del grupo de los Listeners (escuchadores). ActionListener tiene un sólo método: void actionPerformed(ActionEvent e). ActionListener se usa para detectar y manejar eventos de acción (ActionEvent): los que tienen lugar cuando se produce una acción sobre un elemento del programa.

Un evento ActionEvent se produce:

• al pulsar un botón (Button)
• al hacer doble clic en un elemento de lista (List)
• al pulsar INTRO en una caja de texto (TextFiel)
• al elegir un menú (MenuItem)

Los distintos elementos del programa (botones, etc...) están  vigilados por Listeners que detectan las acciones que tienen lugar sobre el elemento vigilado. Cuando ActionListener detecta una acción (por ejemplo: pulsar sobre un botón) se genera un evento de acción (ActionEvent) en el elemento (botón). Los ActionEvent invocan el método actionPerformed(ActionEvent e) que realiza las acciones programadas ante ese evento. La clase que implementa ActionListener ha de importar el paquete java.awt.event.*.

De manera que cuando el usuario pulsa un botón:

1. el botón sobre el que se produce una acción y genera un evento (event source, este dato se puede obtener con el método getSource) ha de estar previamente registrado con algún objeto que gestione el evento (ActionListener en este caso) mediante el método:

   boton.addActionListener(ActionListener nombre_de_actionListener)

2. el botón genera un ActionEvent (clase del paquete java.awt.event)
    
3. ActionEvent invoca al método actionPerformed que realiza las acciones programadas
    
4. si la clase implementa ActionListener, el método public void actionPerformed(ActionEvent e) ha de ser sobreescrito (override)

A continuación se muestran los aspectos más destacados del código en 4 versiones diferentes:

• la clase pricipal implementa ActionListener; el registro del botón con ActionListener es:
  

  boton.addActionListener(this);
  //
   public void actionPerformed(ActionEvent e) {
  ... código ... ;
  }
  

• la clase principal no implementa ActionListener pero sí lo hace otra clase; el botón es registrado con ActionListener asociándolo a una nueva instancia de esta clase:
  

  boton.addActionListener(new ClaseClicEnBoton());
  //
  class ClaseClicEnBoton implements ActionListener {
  public void actionPerformed(ActionEvent e) {
  ... código ... ;
   }
  }
  

• la clase principal no implementa ActionListener; el botón es registrado con ActionListener asociándolo a una nueva instancia de la clase ActionListener:
  

  boton.addActionListener(new ActionListener() {
  public void actionPerformed(ActionEvent e) {
      clicEnBoton(e); }
  });
  
  private void clicEnBoton(ActionEvent e) {
        ... código ... ;
  }

• en caso de tener que detectar el botón que origina un evento (event source) entre varios botones registrados con un ActionListener, puede ser útil recurrir al método setActionCommand, que establece un nombre, independiente de su etiqueta, para el botón:
  

  boton1.setActionCommand ("nombre_ActionCommand1");
  boton2.setActionCommand ("nombre_ActionCommand2");

  posteriormente se emplea una estructura condicional para elegir la acción dependiendo del botón origen del evento:
  

  public void actionPerformed(ActionEvent e) {
        //si se ha pulsado en el botón 1 (si ActionCommand es nombre_ActionCommand1)
      if ("nombre_ActionCommand1".equals(e.getActionCommand())) {
       ... código ... ; }
        //si se ha pulsado en el botón 2 (si ActionCommand es nombre_ActionCommand2)
      else if ("nombre_ActionCommand2".equals(e.getActionCommand())) {
        ... código ... ; }
      }

• Declarar la clase principal del programa (esta clase sí implementa la interfaz ActionListener):
  
  class action_Listener1 implements ActionListener { ... }
   
• Registrar el botón con la propia clase a que pertenece (ya que implementa ActionListener):
  

  boton1.addActionListener(this);

•  El método actionPerformed contiene las instrucciones que ejecutan la acción deseada:
  

  // LO QUE SUCEDE AL PULSAR EL BOTÓN 
    public void actionPerformed(ActionEvent e) {
   	... código ... ;
      }

Código 2: la clase principal no implementa ActionListener

• Declarar la clase principal del programa (esta clase no implementa la interfaz ActionListener):
  
  class action_Listener1 { ... }
   
• Registrar el botón con una instancia de la Interface ActionListener:
  

  boton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
          clicEnBoton(e); }
      });

•  El método clicEnBoton contiene las instrucciones que ejecutan la acción deseada:
  

  private void clicEnBoton(ActionEvent evt) {
        ... código ... ;
      }

Código 3: la clase principal no implementa ActionListener

• Declarar la clase principal del programa (esta clase no implementa la interfaz ActionListener):
  
  class action_Listener1 { ... }
   
• Crear una nueva clase implementando ActionListener:
  
  class ClaseClicEnBoton implements ActionListener {
      public void actionPerformed(ActionEvent evt) {
        ... código ...; }
      }
   
• Registrar el botón con una instancia de la clase ClaseClicEnBoton:
  

  boton.addActionListener(new ClaseClicEnBoton());

Código 4: detectar qué botón ha generado el evento

•  Declarar la clase principal del programa (esta clase sí implementa la interfaz ActionListener):
  
  class action_Listener1 implements ActionListener { ... }
   
• Configurar la propiedad ActionCommand de los botones:
  

  boton1.setActionCommand ("nombre_ActionCommand1");
  boton2.setActionCommand ("nombre_ActionCommand2");

• Registrar los botones con la propia clase a que pertenecen (ya que implementa ActionListener):
  

  boton1.addActionListener(this);
  boton2.addActionListener(this);

• Recuperar el valor de la propiedad ActionCommand para saber cuál es el botón que ha generado el evento:
  
  public void actionPerformed(ActionEvent e) {
        //si se ha pulsado en el botón 1 (si ActionCommand es nombre_ActionCommand1)
      if ("nombre_ActionCommand1".equals(e.getActionCommand())) {
       ... código ... ; }
        //si se ha pulsado en el botón 2 (si ActionCommand es nombre_ActionCommand2)
      else if ("nombre_ActionCommand2".equals(e.getActionCommand())) {
        ... código ... ; }
      }

Código común

• Es necesario importar los paquetes requeridos para el manejo de eventos:
  
  import java.awt.*;
  import javax.swing.*;
  import java.awt.event.*;
   
• Al crear y mostrar la ventana es posible configurar la posición centrada en la pantalla. setLocationRelativeTo(null) ha de ir colocado cuando ya se ha configurado adecuadamente el tamaño de la ventana:
  
  ventana.setSize(220,100);
  ventana.setLocationRelativeTo(null); //centrar el formulario en la pantalla
  ventana.setResizable(false);
  ventana.setVisible(true);
   
• Todos los métodos de las Intefaces son públicos, por lo que al sobrescribir el método actionPerformed hay que declararlo como public:
  
  public void actionPerformed(ActionEvent e) {
        ... código ... ; }
      }

Aplicación de ejemplo

Imagen del programa en funcionamiento

Se trata de una ventana con una etiqueta para mostrar un número y 4 botones de comando; cada botón,al ser pulsado, implementa la acción de forma diferente, según lo referido más arriba; todos ellos suman una cifra al número mostrado.

Código Java.