Corso di Java

(senza pretese)

Lezione otto: interagire con l'applicazione (gli Action Listeners)

Action listeners
Come lascia facilmente capire il nome di questi elementi, lo scopo degli action listeners è quello di 'ascoltare' le azioni che vengono compiute all'interno dell'applicazione che abbiamo creato.
Per fare in modo che una applicazione si accorga di quello che succede è necessario che la classe implementi questi gestori di azioni. Per farlo è sufficiente aggiungere implements ActionListener alla dichiarazione della classe. Ecco quindi come appare una classe che gestisce gli eventi che accadono al suo interno:

public class Pippo extends JFrame implements ActionListener
{
//Tutto il codice necessario
//per l'applicazione
}

Il fatto che estenda JFrame, abbiamo già visto che è necessario per poter disegnare la finestra sullo schermo.

Ma come si fa a usare gli action listeners? Innanzitutto dobbiamo individuare tutti quegli elementi che all'interno della nostra applicazione possono 'reagire' in qualche modo all'intervento dell'utente. Per spiegarmi meglio vi farò un esempio che ha come soggetto un bottone.
Come avete già visto nella sesta lezione un bottone da solo non fa nulla (se non cambiare aspetto quando si clicca). Allora per poter interagire con esso bisogna associargli un actionListener (inizierò per maggior chiarezza a chiamarli come ho appena fatto). Ecco quindi come creare un bottone e associargli un 'ascoltatore':

JButton bottone = new JButton("Cliccami!!!);
bottone.addActionListener(this);

Come avete visto si usa il metodo addActionListener(this), ma cosa significa quel 'this'? Significa che il codice che si occupa di gestire gli eventi sarà scritto all'interno della classe stessa. Altrimenti al suo posto si può mettere il nome della classe (creata da voi) che se ne occupa. Per le piccole applicazione vi consiglio di usare la stessa classe (ma poi fate sempre come vi torna meglio, mi raccomando! Accettate i consigli, ma poi fate sempre come volete [regola numero uno del programmatore]).

Che forma ha il codice che si occupa di gestire gli eventi?
L'interfaccia ActionListener ha un solo metodo per gestire gli eventi: actionPerformed.
Ecco come si possono gestire gli eventi facendo ricorso al metodo appena nominato:

public void actionPerformed(ActionEvent evento)
{
//Codice di gestione evento
}

L'argomento del metodo è il tipo di evento che si è verificato all'interno dell'applicazione su un componente a cui è stato associato un actionListener.
L'unica cosa importante che bisogna sapere è il seguente pezzetto di codice:

Object sorgente = evento.getSource();

Con questo metodo creiamo un oggetto (il più generico possibile, in modo tale che ogni volta che accade un evento sorgente rispecchi tale oggetto) a cui viene assegnato il valore evento.getSource() ovvero il nome dell'oggetto che ha generato l'evento stesso.

Vediamo dettagliatamente il codice di una applicazione che consiste di due bottoni che, se premuti, fanno apparire un box con una scritta relativa a quale dei due è stato cliccato.
Il codice è come al solito in giallo, mentre in celeste ci sono i commenti al codice (Nota: ogni commento si riferisce all'elemento che gli sta sopra, ovvero prima scrivo il codice poi spiego a cosa serve).

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

/*Importo tutto il pakage javax.swing. L'asterisco serve a 
  includere tutti gli elementi di quel pakage ma NON le
  sottocartelle! Come è possibile notare subito sotto,
  quando si fa l'import del pakage java.awt per poter usare
  i layout, dobbiamo anche importare java.awt.event per usare
  gli actionListener.
*/


public class ac_lis extends JFrame implements ActionListener
{
//Estendo JFrame per creare le finestre e si implementano gli
//actionListener (tramite l'interfaccia ActionListener)


 JButton bottone_uno = new JButton("Cliccami!");
 JButton bottone_due = new JButton("Clicca anche me!");
//I due bottoni


 JPanel pann_principale = new JPanel();
//Il pannello che conterrà i bottoni


  public ac_lis(String titolo)
  {
/*Costruttore della classe. L'argomento String è la scritta
  che andrà nella barra del titolo tramite l'istruzione qui sotto
*/

   super(titolo);

   GridLayout grid_lay = new GridLayout(1,2);
//Creiamo un layout a griglia per la nostra finestra...

   pann_principale.setLayout(grid_lay);
//...e associamolo al pannello principale.

/*Per i più smaliziati e 'precoci' c'è da dire che si
  poteva risparmiare una riga scrivendo direttamente

  pann_principale.setLayout(new GridLayout(1,2));

  ottenendo lo stesso risultato, ma siamo qui per imparare
  ed è meglio fare tutti i passaggi.
*/



   bottone_uno.addActionListener(this);
   bottone_due.addActionListener(this);
//Associo l'action listener ai due bottoni


   pann_principale.add(bottone_uno);
   pann_principale.add(bottone_due);
/*Aggiungo i bottoni al pannello. Notate che vengono inseriti
  da sinistra a destra (nelle righe) e finita la riga si passa 
  al quella sottostante, ripartendo da sinistra e andando verso
  destra
*/

   setContentPane(pann_principale);
   pann_principale.setVisible(true);
/*Impostiamo pann_principale come ContentPane e lo
  rendiamo visibile
*/

  }

  public static void main(String args[])
   {
/*La funzione principale della nostra applicazione. Da qui
  si crea la finestra e la si riempie con gli elementi creati
  nella classe
*/



  try {
    UIManager.setLookAndFeel(
         UIManager.getSystemLookAndFeelClassName());
         }
    catch (Exception e)
    {
     JOptionPane.showMessageDialog(null, "Impossibile"+
     " impostare lo stile "+e);
    }
/*Impostiamo la GUI (interfaccia grafica) tramite l'UIManager,
  dicendogli che la finestra deve apparire con lo stile del
  sistema operativo usato (quindi con un solo codice, abbiamo
  una UI differente se si usa Windows oppure uno Unix). Il
  blocco try...catch verrà spiegato in una successiva lezione,
  adesso prendetelo così come è.
*/


    ac_lis es_lis = new ac_lis("Esempio di"+
    " funzionamento degli action listeners by AlexMfM");
/*Creiamo una istanza della nostra classe. La stringa argomento 
  dell'oggetto è il titolo della finestra.
*/

    es_lis.resize(300,50);
//Imposto le dimensioni della finestra

    es_lis.show();
//'Mostriamo' la finestra


    WindowListener l = new WindowAdapter()
    {public void windowClosing(WindowEvent e)
    {System.exit(0);
     }
    };
    es_lis.addWindowListener(l);
/*Il windowListener serve per far sparire la finestra alla 
  pressione del tasto con la X nella barra menu. Creato questo
  oggetto lo si assegna alla finestra.
*/


    es_lis.setVisible(true);
//Rendiamo visibile la finestra


   }

   public void actionPerformed(ActionEvent evento)
    {
/*Metodo che serve per gestire gli eventi. Il suo argomento
  è l'evento che si è verificato.
*/

     Object src = evento.getSource();
/*Creiamo una variabile di tipo Object che contenga l'elemento
  dove si è verificato l'evento
*/


     if (src==bottone_uno)
     {
      JOptionPane.showMessageDialog(null,
      "Hai premuto il bottone a sinistra",
      "Bottone sinistro premuto!", 
      JOptionPane.WARNING_MESSAGE);
/*Se l'oggetto su cui è accaduto l'evento è il primo
  bottone appare un box di messaggio relativo ad esso.
*/


     }
     if (src==bottone_due)
     {
      JOptionPane.showMessageDialog(null, 
      "Hai premuto il bottone a destra",
      "Bottone destro premuto!", 
      JOptionPane.WARNING_MESSAGE);
/*Se l'oggetto su cui è accaduto l'evento è il secondo
  bottone appare un box di messaggio relativo ad esso.
*/

     }


     }

}

Provate pure a compilare e lanciare il programma e vedrete il risultato. Visto che da questo programma è venuto a galla un blocco di codice di cui non avevamo ancora parlato, nella prossima lezione verdrò di chiarire cosa sono e come funzionano i blocchi try...catch!
Alla prossima!

Prossima pagina

Indice Webdesign