SWING - Gestione degli eventi

In questo capitolo imparerai gli eventi, i suoi tipi e imparerai anche come gestire un evento. Un esempio è fornito alla fine del capitolo per una migliore comprensione.

Cos'è un evento?

Il cambiamento nello stato di un oggetto è noto come Event, ovvero l'evento descrive il cambiamento nello stato della sorgente. Gli eventi vengono generati come risultato dell'interazione dell'utente con i componenti dell'interfaccia utente grafica. Ad esempio, fare clic su un pulsante, spostare il mouse, immettere un carattere tramite la tastiera, selezionare un elemento dall'elenco e scorrere la pagina sono le attività che provocano il verificarsi di un evento.

Tipi di evento

Gli eventi possono essere classificati a grandi linee in due categorie:

Foreground Events- Questi eventi richiedono l'interazione diretta dell'utente. Vengono generati come conseguenza dell'interazione di una persona con i componenti grafici dell'interfaccia utente grafica. Ad esempio, fare clic su un pulsante, spostare il mouse, immettere un carattere tramite la tastiera, selezionare un elemento dall'elenco, scorrere la pagina, ecc.
Background Events- Questi eventi richiedono l'interazione dell'utente finale. Interruzioni del sistema operativo, guasti hardware o software, scadenza del timer e completamento dell'operazione sono alcuni esempi di eventi in background.

Cos'è la gestione degli eventi?

La gestione degli eventi è il meccanismo che controlla l'evento e decide cosa dovrebbe accadere se si verifica un evento. Questo meccanismo ha un codice noto come gestore di eventi, che viene eseguito quando si verifica un evento.

Java utilizza il modello di eventi di delega per gestire gli eventi. Questo modello definisce il meccanismo standard per generare e gestire gli eventi.

Il modello di eventi di delega ha i seguenti partecipanti chiave.

Source- La sorgente è un oggetto su cui si verifica l'evento. La fonte è responsabile di fornire le informazioni sull'evento che si è verificato al proprio gestore. Java ci fornisce le classi per l'oggetto sorgente.
Listener- È anche noto come gestore di eventi. L'ascoltatore è responsabile della generazione di una risposta a un evento. Dal punto di vista dell'implementazione Java, l'ascoltatore è anche un oggetto. L'ascoltatore attende di ricevere un evento. Una volta ricevuto l'evento, l'ascoltatore elabora l'evento e quindi ritorna.

Il vantaggio di questo approccio è che la logica dell'interfaccia utente è completamente separata dalla logica che genera l'evento. L'elemento dell'interfaccia utente è in grado di delegare l'elaborazione di un evento a una parte di codice separata.

In questo modello, il listener deve essere registrato con l'oggetto di origine in modo che il listener possa ricevere la notifica dell'evento. Questo è un modo efficiente di gestire l'evento perché le notifiche degli eventi vengono inviate solo a quei listener che vogliono riceverle.

Passaggi coinvolti nella gestione degli eventi

Step 1 - L'utente fa clic sul pulsante e l'evento viene generato.

Step 2 - L'oggetto della classe di eventi interessati viene creato automaticamente e le informazioni sulla sorgente e sull'evento vengono popolate all'interno dello stesso oggetto.

Step 3 - L'oggetto evento viene inoltrato al metodo della classe listener registrata.

Step 4 - Il metodo viene eseguito e restituito.

Punti da ricordare sull'ascoltatore

Per progettare una classe listener, è necessario sviluppare alcune interfacce listener. Queste interfacce Listener prevedono alcuni metodi di callback astratti pubblici, che devono essere implementati dalla classe listener.
Se non implementate nessuna delle interfacce predefinite, la vostra classe non può agire come una classe listener per un oggetto sorgente.

Metodi di richiamata

Questi sono i metodi forniti dal provider API e sono definiti dal programmatore dell'applicazione e richiamati dallo sviluppatore dell'applicazione. Qui i metodi di callback rappresentano un metodo di evento. In risposta a un evento, java jre attiverà il metodo di callback. Tutti questi metodi di callback sono forniti nelle interfacce del listener.

Se un componente desidera che un ascoltatore ascolti i suoi eventi, la sorgente deve registrarsi all'ascoltatore.

Esempio di gestione degli eventi

Crea il seguente programma Java utilizzando qualsiasi editor di tua scelta D:/ > SWING > com > tutorialspoint > gui >

SwingControlDemo.java

package com.tutorialspoint.gui;

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

public class SwingControlDemo {
   private JFrame mainFrame;
   private JLabel headerLabel;
   private JLabel statusLabel;
   private JPanel controlPanel;

   public SwingControlDemo(){
      prepareGUI();
   }
   public static void main(String[] args){
      SwingControlDemo swingControlDemo = new SwingControlDemo();  
      swingControlDemo.showEventDemo();       
   }
   private void prepareGUI(){
      mainFrame = new JFrame("Java SWING Examples");
      mainFrame.setSize(400,400);
      mainFrame.setLayout(new GridLayout(3, 1));

      headerLabel = new JLabel("",JLabel.CENTER );
      statusLabel = new JLabel("",JLabel.CENTER);        
      statusLabel.setSize(350,100);
      
      mainFrame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent windowEvent){
            System.exit(0);
         }        
      });    
      controlPanel = new JPanel();
      controlPanel.setLayout(new FlowLayout());

      mainFrame.add(headerLabel);
      mainFrame.add(controlPanel);
      mainFrame.add(statusLabel);
      mainFrame.setVisible(true);  
   }
   private void showEventDemo(){
      headerLabel.setText("Control in action: Button"); 

      JButton okButton = new JButton("OK");
      JButton submitButton = new JButton("Submit");
      JButton cancelButton = new JButton("Cancel");

      okButton.setActionCommand("OK");
      submitButton.setActionCommand("Submit");
      cancelButton.setActionCommand("Cancel");

      okButton.addActionListener(new ButtonClickListener()); 
      submitButton.addActionListener(new ButtonClickListener()); 
      cancelButton.addActionListener(new ButtonClickListener()); 

      controlPanel.add(okButton);
      controlPanel.add(submitButton);
      controlPanel.add(cancelButton);       

      mainFrame.setVisible(true);  
   }
   private class ButtonClickListener implements ActionListener{
      public void actionPerformed(ActionEvent e) {
         String command = e.getActionCommand();  
         
         if( command.equals( "OK" ))  {
            statusLabel.setText("Ok Button clicked.");
         } else if( command.equals( "Submit" ) )  {
            statusLabel.setText("Submit Button clicked."); 
         } else {
            statusLabel.setText("Cancel Button clicked.");
         }  	
      }		
   }
}

Compila il programma utilizzando il prompt dei comandi. Vai aD:/ > SWING e digita il seguente comando.

D:\AWT>javac com\tutorialspoint\gui\SwingControlDemo.java

Se non si verifica alcun errore, significa che la compilazione è riuscita. Eseguire il programma utilizzando il seguente comando.

D:\AWT>java com.tutorialspoint.gui.SwingControlDemo

Verificare il seguente output.