java - ejemplo - JCheckbox-ActionListener y ItemListener?

jcheckbox is checked

Question

¿ActionListener y ItemListener se utilizan para activar un evento con JCheckBox?

Entonces, ¿cuál es la diferencia entre ellos y en cuyo caso uno de ellos es preferible al otro?

Answer 1

Como referencia, aquí hay una sscce que ilustra la diferencia. Consola:

SELECTED ACTION_PERFORMED DESELECTED ACTION_PERFORMED

Código:

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://.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 2

He estado probando esto yo mismo, y mirando todas las respuestas en esta publicación y no creo que respondan muy bien a esta pregunta. Experimenté para obtener una buena respuesta (código a continuación). PUEDE desencadenar cualquier evento con ActionListener y ItemListener el 100% del tiempo cuando se cambia un estado en un botón de opción o en una casilla de verificación, o cualquier otro tipo de elemento de Swing que asuma, ya que es un tipo Object. La ÚNICA diferencia que puedo decir entre estos dos oyentes es que el tipo de objeto de evento que se devuelve con el oyente es diferente. Y obtienes un mejor tipo de evento con una casilla de verificación usando un ItemListener en lugar de un ActionListener.

Los tipos de devolución de un evento de acción y un evento de artículo tendrán almacenados diferentes métodos que pueden usarse cuando se dispara un tipo de evento. En el siguiente código, los comentarios muestran la diferencia en los métodos .get para cada tipo de evento devuelto por la clase.

El siguiente código configura un JPanel simple con JRadioButtons, JCheckBoxes y una pantalla JLabel que cambia según las configuraciones de los botones. Configuré todos los RadioButtons y CheckBoxes con un Listener de Acción y un Listener de Elemento. Luego escribí las clases de Listener a continuación con ActionListener completamente comentado porque lo probé primero en este experimento. Notarás que si agregas este panel a un recuadro y a una pantalla, todos los botones de radio y las casillas de verificación siempre se disparan independientemente del tipo de Oyente, solo comenta los métodos en uno y prueba el otro y viceversa.

Tipo de devolución en los métodos implementados es la diferencia PRINCIPAL entre los dos. Ambos oyentes disparan eventos de la misma manera. Explicado un poco mejor en el comentario anterior es la razón por la cual una casilla de verificación debería usar un ItemListener sobre ActionListener debido al tipo de evento que se devuelve.

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);
}
}
}
}

Answer 3

La diferencia es que ActionEvent se ActionEvent cuando la acción se realiza en JCheckBox es decir, su estado se cambia haciendo clic en él con el mouse o con una barra espaciadora o un mnemónico. Realmente no escucha los eventos de cambio si JCheckBox está seleccionado o no seleccionado.

Por ejemplo, si JCheckBox c1 (por ejemplo) se agrega a un ButtonGroup . Cambiar el estado de otras JCheckBoxes en ButtonGroup no ActionEvent un ActionEvent en otra JCheckBox , sino que se ItemEvent un ItemEvent .

Palabras finales: un ItemEvent se dispara incluso cuando el usuario anula la selección de una casilla de verificación seleccionando otra JCheckBox (cuando está en un ButtonGroup ), sin embargo ActionEvent no se genera así, ActionEvent solo escucha si se realiza una acción en la JCheckBox (a la que JCheckBox el ActionListener está registrado solo) o no. No sabe sobre ButtonGroup y todas las otras cosas de selección / deselección.

Answer 4

Yo uso addActionListener para JButtons mientras que addItemListener es más conveniente para un JToggleButton . Junto con if(event.getStateChange()==ItemEvent.SELECTED) , en este último caso, agrego eventos para cada vez que JToggleButton esté marcado / desmarcado.

Answer 5

Tanto ItemListener como ActionListener , en el caso de JCheckBox tienen el mismo comportamiento. Sin embargo, la principal diferencia es que ItemListener se puede activar llamando a setSelected(true) en la casilla de verificación. Como práctica de codificación, no registre tanto ItemListener como ActionListener con JCheckBox , para evitar incoherencias.