JCheckbox - ActionListener e ItemListener?

Question

Sia ActionListener che ItemListener vengono utilizzati per attivare un evento con JCheckBox?

Quindi, qual è la differenza tra di loro e nel qual caso uno di essi è preferito all'altro?

Answer 1

Entrambi ItemListener e ActionListener, in caso di JCheckBox hanno lo stesso comportamento. Tuttavia, la differenza principale è ItemListener che può essere attivata chiamando il setSelected(true) sulla casella di controllo. Come pratica di codifica non registrare sia ItemListener che ActionListener con JCheckBox, per evitare incoerenze.

Answer 2

Per riferimento, ecco uno sscce che illustra la differenza. Console:

 
SELECTED 
ACTION_PERFORMED 
DESELECTED 
ACTION_PERFORMED 

Codice:

import java.awt.EventQueue; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.awt.event.ItemEvent; 
import java.awt.event.ItemListener; 
import javax.swing.JCheckBox; 
import javax.swing.JFrame; 
import javax.swing.JPanel; 

/** @see http://stackoverflow.com/q/9882845/230513 */ 
public class Listeners { 

    private void display() { 
     JFrame f = new JFrame("Listeners"); 
     f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     JCheckBox b = new JCheckBox("JCheckBox"); 
     b.addActionListener(new ActionListener() { 

      @Override 
      public void actionPerformed(ActionEvent e) { 
       System.out.println(e.getID() == ActionEvent.ACTION_PERFORMED 
        ? "ACTION_PERFORMED" : e.getID()); 
      } 
     }); 
     b.addItemListener(new ItemListener() { 

      @Override 
      public void itemStateChanged(ItemEvent e) { 
       System.out.println(e.getStateChange() == ItemEvent.SELECTED 
        ? "SELECTED" : "DESELECTED"); 
      } 
     }); 
     JPanel p = new JPanel(); 
     p.add(b); 
     f.add(p); 
     f.pack(); 
     f.setLocationRelativeTo(null); 
     f.setVisible(true); 
    } 

    public static void main(String[] args) { 
     EventQueue.invokeLater(new Runnable() { 

      @Override 
      public void run() { 
       new Listeners().display(); 
      } 
     }); 
    } 
} 

Answer 3

La differenza è che ActionEvent viene attivato quando l'azione viene eseguita sul JCheckBox che è stato è cambiato facendo clic su di esso con il mouse o con una barra spaziatrice o un mnemonico. Non è davvero ascoltare cambiare eventi se lo JCheckBox è selezionato o deselezionato.

Ad esempio, se JCheckBox c1 (ad esempio) viene aggiunto a un ButtonGroup. La modifica dello stato di altri JCheckBoxes nel ButtonGroup non attiva un ActionEvent su un altro JCheckBox, viene invece eseguito un ItemEvent.

parole finale: Un ItemEvent viene attivato anche quando l'utente deseleziona una casella di controllo selezionando un'altra JCheckBox (quando in un ButtonGroup), tuttavia ActionEvent non è generato come quella invece ActionEvent solo ascolti se l'azione viene eseguita sul JCheckBox (a cui è registrato solo lo ActionListener) o no. Non sa di ButtonGroup e di tutte le altre cose di selezione/deselezione.

Answer 4

Io uso addActionListener per JButtons mentre è più conveniente per un JToggleButton. Insieme a if(event.getStateChange()==ItemEvent.SELECTED), in quest'ultimo caso, aggiungo Eventi per ogni volta che JToggleButton è selezionato/deselezionato.

Answer 5

L'ho provato personalmente e ho esaminato tutte le risposte a questo post e non penso che rispondano molto bene a questa domanda. Ho sperimentato me stesso per ottenere una buona risposta (codice sotto). È possibile attivare entrambi gli eventi con ActionListener e ItemListener il 100% del tempo in cui uno stato viene modificato in un pulsante di opzione o in una casella di controllo o in qualsiasi altro tipo di elemento Swing che presumo poiché è di tipo Object. L'unica differenza che posso distinguere tra questi due listener è il tipo di oggetto evento che viene restituito con l'ascoltatore diverso. E ottieni un tipo di evento migliore con una casella di controllo che utilizza un ItemListener anziché un ActionListener.

I tipi restituiti di ActionEvent e ItemEvent disporranno di metodi diversi che possono essere utilizzati quando viene attivato un tipo di evento. Nel codice sottostante i commenti mostrano la differenza nei metodi .get per ogni tipo di evento restituito dalla classe.

Il codice seguente imposta un semplice JPanel con JRadioButtons, JCheckBoxes e un display JLabel che cambia in base alle configurazioni dei pulsanti. Ho impostato tutti i RadioButton e i CheckBox con un Listener di azioni e un Listener di elementi. Quindi ho scritto le classi Listener qui sotto con ActionListener completamente commentato perché l'ho testato prima in questo esperimento. Si noterà che se si aggiunge questo pannello a una cornice e si visualizza, tutti i pulsanti di opzione e le caselle di spunta si attivano sempre indipendentemente dal tipo di Listener, basta commentare i metodi in uno e provare l'altro e viceversa.

Il tipo di ritorno nei metodi implementati è la differenza MAIN tra i due. Entrambi gli ascoltatori attivano gli eventi allo stesso modo. Spiegato un po 'meglio nel commento sopra è il motivo per cui una casella di controllo dovrebbe utilizzare un ItemListener su ActionListener a causa del tipo di evento che viene restituito.

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

public class RadioButtonsAndCheckBoxesTest extends JPanel{ 
JLabel display; 
String funny, serious, political; 
JCheckBox bold,italic; 
JRadioButton funnyQuote, seriousQuote, politicalQuote; 
ButtonGroup quotes; 

    public RadioButtonsAndCheckBoxesTest(){ 
     funny = "You are not ugly, you were just born... different"; 
     serious = "Recommend powdered soap in prison!"; 
     political = "Trump can eat a little Bernie, but will choke on his  Birdie"; 

     display = new JLabel(funny); 
     Font defaultFont = new Font("Ariel",Font.PLAIN,20); 
     display.setFont(defaultFont); 

     bold = new JCheckBox("Bold",false); 
     bold.setOpaque(false); 
     italic = new JCheckBox("Italic",false); 
     italic.setOpaque(false); 

     //Color itemBackground = 

     funnyQuote = new JRadioButton("Funny",true); 
     funnyQuote.setOpaque(false); 
     seriousQuote = new JRadioButton("Serious"); 
     seriousQuote.setOpaque(false); 
     politicalQuote = new JRadioButton("Political"); 
     politicalQuote.setOpaque(false); 

     quotes = new ButtonGroup(); 
     quotes.add(funnyQuote); 
     quotes.add(seriousQuote); 
     quotes.add(politicalQuote); 

     JPanel primary = new JPanel(); 
     primary.setPreferredSize(new Dimension(550, 100)); 

     Dimension standard = new Dimension(500, 30); 

     JPanel radioButtonsPanel = new JPanel(); 
     radioButtonsPanel.setPreferredSize(standard); 
     radioButtonsPanel.setBackground(Color.green); 
     radioButtonsPanel.add(funnyQuote); 
     radioButtonsPanel.add(seriousQuote); 
     radioButtonsPanel.add(politicalQuote); 

     JPanel checkBoxPanel = new JPanel(); 
     checkBoxPanel.setPreferredSize(standard); 
     checkBoxPanel.setBackground(Color.green); 
     checkBoxPanel.add(bold); 
     checkBoxPanel.add(italic); 

     primary.add(display); 
     primary.add(radioButtonsPanel); 
     primary.add(checkBoxPanel); 

     //Add Action Listener To test Radio Buttons 
     funnyQuote.addActionListener(new ActionListen()); 
     seriousQuote.addActionListener(new ActionListen()); 
     politicalQuote.addActionListener(new ActionListen()); 

     //Add Item Listener to test Radio Buttons 
     funnyQuote.addItemListener(new ItemListen()); 
     seriousQuote.addItemListener(new ItemListen()); 
     politicalQuote.addItemListener(new ItemListen()); 

     //Add Action Listener to test Check Boxes 
     bold.addActionListener(new ActionListen()); 
     italic.addActionListener(new ActionListen()); 

     //Add Item Listener to test Check Boxes 
     bold.addItemListener(new ItemListen()); 
     italic.addItemListener(new ItemListen()); 

     //adds primary JPanel to this JPanel Object 
     add(primary); 
    } 

    private class ActionListen implements ActionListener{ 

     public void actionPerformed(ActionEvent e) { 

     /* 
     Different Get Methods from ItemEvent 
     e.getWhen() 
     e.getModifiers() 
     e.getActionCommand()*/ 

      /*int font=Font.PLAIN; 
      if(bold.isSelected()){ 
       font += Font.BOLD; 
      } 
      if(italic.isSelected()){ 
       font += Font.ITALIC; 
      } 
      display.setFont(new Font("Ariel",font,20)); 

      if(funnyQuote.isSelected()){ 
       display.setText(funny); 
      } 
      if(seriousQuote.isSelected()){ 
       display.setText(serious); 
      } 
      if(politicalQuote.isSelected()){ 
       display.setText(political); 
      }*/ 
     } 
    } 
    private class ItemListen implements ItemListener { 

     public void itemStateChanged(ItemEvent arg0) { 

      /* 
      Different Get Methods from ActionEvent 
      arg0.getItemSelectable() 
      arg0.getStateChange() 
      arg0.getItem()*/ 


      int font=Font.PLAIN; 
      if(bold.isSelected()){ 
       font += Font.BOLD; 
      } 
      if(italic.isSelected()){ 
       font += Font.ITALIC; 
      } 
      display.setFont(new Font("Ariel",font,20)); 

      if(funnyQuote.isSelected()){ 
       display.setText(funny); 
      } 
      if(seriousQuote.isSelected()){ 
       display.setText(serious); 
      } 
      if(politicalQuote.isSelected()){ 
       display.setText(political); 
      } 

     } 

    } 
}