difficulté à connecter un écouteur d'action à un bouton radio

Comme il y a beaucoup de choses à améliorer dans votre code, j'ai pensé que j'écrirais un exemple de programme pour vous montrer comment faire ce genre de chose dans Swing. Essayez-le et voyez. (Il y a aussi peu de choses que nous pouvons améliorer dans cet exemple de code. Mais je voulais juste garder les choses simples et ne traiter que les points clés.)

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

public class Questions {

  public static void main(String[] args) {
    JFrame f = new JFrame("Questions");
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.getContentPane().add(new QuestionPanel());
    f.setBounds(300, 200, 400, 300);
    f.setVisible(true);
  }
}

class QuestionPanel extends JPanel implements ActionListener {

  private static final String ANSWER_1_TEXT = "Answer 1";
  private static final String ANSWER_2_TEXT = "Answer 2";
  private static final String ANSWER_3_TEXT = "Answer 3";

  private JRadioButton answer1;
  private JRadioButton answer2;
  private JRadioButton answer3;

  QuestionPanel() {

    answer1 = new JRadioButton(ANSWER_1_TEXT);
    answer2 = new JRadioButton(ANSWER_2_TEXT);
    answer3 = new JRadioButton(ANSWER_3_TEXT);

    answer1.addActionListener(this);
    answer2.addActionListener(this);
    answer3.addActionListener(this);

    ButtonGroup buttonGroup = new ButtonGroup();
    buttonGroup.add(answer1);
    buttonGroup.add(answer2);
    buttonGroup.add(answer3);

    setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
    add(answer1);
    add(answer2);
    add(answer3);
  }

  @Override
  public void actionPerformed(ActionEvent e) {

    JRadioButton selectedAnswer = (JRadioButton) e.getSource();
    if (selectedAnswer == answer1) {
      answer1.setText(ANSWER_1_TEXT + " (selected)");
      answer2.setText(ANSWER_2_TEXT);
      answer3.setText(ANSWER_3_TEXT);
    }
    else if (selectedAnswer == answer2) {
      answer1.setText(ANSWER_1_TEXT);
      answer2.setText(ANSWER_2_TEXT + " (selected)");
      answer3.setText(ANSWER_3_TEXT);
    }
    else if (selectedAnswer == answer3) {
      answer1.setText(ANSWER_1_TEXT);
      answer2.setText(ANSWER_2_TEXT);
      answer3.setText(ANSWER_3_TEXT + " (selected)");
    }
  }
}

Votre principal problème est ici:

public void actionPerformed(ActionEvent ae) {
    JRadioButton b = (JRadioButton) ae.getSource();
    b.setText("this works");
}

Vous créez un ActionListener mais vous ne l'appelez jamais.

Vous héritez également de ClickListener mais ne l'utilisez jamais.

createComponents(frame.getContentPane());

Dans votre code, vous appelez:

listeners = new ClickListener();

Donc , vous dites à votre JRadioButton d'avoir un auditeur qui est null.

Donc, ici vous avez 2 approches:

1. Supprimez les écouteurs privés ActionListener; du haut de votre programme et modifiez:

   b.addActionListener(listeners);
   

   À:

   b.addActionListener(this);
   

2. Supprimez étend ClickListener de votre définition de classe et conservez:

   b.addActionListener(listeners);
   

   Mais en ajoutant

   b.addActionListener(listeners); //Listeners is null!
   

   Avant

   public class UserInterface extends ClickListener implements Runnable
   

IMO Je prendrais la deuxième approche.

BTW pour votre ActionListener pour changer réellement le texte dont vous n'avez pas besoin private code > variables mais récupérez plutôt la source et lancez-la. Par exemple:

private ActionListener listeners;

Vous avez oublié de mentionner, veuillez suivre Conventions de dénomination Java afin que votre programme soit plus lisible et compréhensible par tous ceux qui le lisent.

• firstWordLowerCaseVariable
• firstWordLowerCaseMethod()
• FirstWordUpperCaseClass
• ALL_WORDS_UPPER_CASE_CONSTANT

Et indentez correctement votre code également :)

Tout d'abord, l'interface graphique ne doit pas étendre la classe d'écouteur. Pas bon. Mieux vaut les garder séparés et passer des références si nécessaire. Par exemple, si l'auditeur a besoin d'une référence à l'interface graphique, transmettez-la en tant que paramètre

De plus, vous voulez apparemment faire est de répondre immédiatement à la sélection JRadioButton avec un comportement utile. J'utiliserais un ItemListener et non un ActionListener, car ItemListener vous dira si le bouton radio a été sélectionné. L'appel de getSource () sur ItemEvent vous donnera le JRadioButton actuel qui a été sélectionné.

par exemple,

class Question {
    private String question;
    private List<String> answers;
    private int correctIndex;

    public Question(String question, List<String> answers, int correctIndex) {
        this.question = question;
        this.answers = answers;
        this.correctIndex = correctIndex;
    }

    public String getQuestion() {
        return question;
    }

    public List<String> getAnswers() {
        return answers;
    }

    public int getCorrectIndex() {
        return correctIndex;
    }

    @Override
    public String toString() {
        return "Question [question=" + question + ", correctIndex="
                + correctIndex + "]";
    }

}

p>

class MyItemListener implements ItemListener {
    private UserInterface2 ui;

    public MyItemListener(UserInterface2 ui) {
        this.ui = ui;
    }

    @Override
    public void itemStateChanged(ItemEvent e) {
        JRadioButton source = (JRadioButton) e.getSource();

        String selected = "The JRadioButton " + source.getText();
        selected += e.getStateChange() == ItemEvent.SELECTED ? " has been selected"
                : " has been unselected";

        // to get the actual Question object get the client property:
        Question question = (Question) source.getClientProperty(UserInterface2.QUESTION);
        // now can get answer Strings and check if correct one selected        
        System.out.println(question);

        String correctAnswer = question.getAnswers().get(question.getCorrectIndex());;
        if (source.getText().equals(correctAnswer)) {
            selected += " and is correct";
        } else {
            selected += " and is incorrect";
        }

        // tell the GUI to display the result
        ui.displayResult(selected);
    }
}

import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.List;

import javax.swing.*;

@SuppressWarnings("serial")
public class UserInterface2 extends JPanel {
    public static final Object QUESTION = "question";
    // fill label with blank text to expand it
    private JLabel resultLabel = new JLabel(String.format("%150s", " "));

    // CardLayout to allow swapping of question panels
    private CardLayout cardLayout = new CardLayout();
    private JPanel centerPanel = new JPanel(cardLayout);

    public UserInterface2(List<Question> questions) {
        centerPanel.setBorder(BorderFactory.createLineBorder(Color.BLUE));
        for (Question question : questions) {
            centerPanel.add(createQPanel(question), question.getQuestion());
        }

        JPanel bottomPanel = new JPanel(new BorderLayout());
        // add button that allows swapping question panels
        bottomPanel.add(new JButton(new AbstractAction("Next") {

            @Override
            public void actionPerformed(ActionEvent e) {
                cardLayout.next(centerPanel);
            }
        }), BorderLayout.LINE_START);
        bottomPanel.add(resultLabel);

        setLayout(new BorderLayout());
        add(bottomPanel, BorderLayout.PAGE_END);
        add(centerPanel);
    }

    private JPanel createQPanel(Question question) {
        JPanel radioPanel = new JPanel(new GridLayout(0, 1));
        radioPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
        ButtonGroup buttonGroup = new ButtonGroup();
        ItemListener myItemListener = new MyItemListener(this);
        for (String answer : question.getAnswers()) {
            JRadioButton answerButton = new JRadioButton(answer);

            // this is present in case you want to extract the Question
            // object from the JRadioButton, useful for if you want to
            // test if the selected answer is correct
            answerButton.putClientProperty(QUESTION, question);

            // add our listener to the JRadioButton
            answerButton.addItemListener(myItemListener);

            // add to button group so only one can be selected
            buttonGroup.add(answerButton);

            // add to JPanel for display
            radioPanel.add(answerButton);
        }

        JPanel qPanel = new JPanel(new BorderLayout());
        qPanel.add(new JLabel(question.getQuestion()), BorderLayout.PAGE_START);
        qPanel.add(radioPanel);
        return qPanel;
    }

    // public method that the item listener will use to display selection
    public void displayResult(String selectedText) {
        resultLabel.setText(selectedText);
    }

    private static void createAndShowGui() {
        // create mock questions
        // likely this information will be in a text file
        List<Question> questions = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            String question = "Question " + i;
            List<String> answers = new ArrayList<>();
            for (int j = 0; j < 4; j++) {
                answers.add(String.format("Answer [%d %d]", i, j));
            }

            int correctIndex = (int) (Math.random() * answers.size());
            // future iteration will also need correctIndex int
            questions.add(new Question(question, answers, correctIndex));
        }

        UserInterface2 mainPanel = new UserInterface2(questions);

        JFrame frame = new JFrame("User Interface");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(mainPanel);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> createAndShowGui());
    }

}

De combien de programmeurs avez-vous besoin pour changer une ampoule? 76, 1 pour le changer et 75 pour dire comment ils auraient pu mieux faire.

Vous avez de mauvaises pratiques de code, mais c'est généralement à cause d'une compréhension fragile des concepts fondamentaux derrière la conception du langage. Je ne commenterai donc pas en quoi votre code est mauvais pour ceci ou cela , expliquez simplement les bases que vous devez connaître.

Pour simplifier, un ActionListener code > est un objet qui réagira sur un ActionPerformedEvent . Définissons-en une, une classe appelée Observer:

Observer n'a aucune idée de qui a généré l'événement, alors dis-lui, et si c'est un JRadioButton, utilisons-le comme un

public class UserInterface implements runnable{
    private ActionListener observer new Observer();
    //...
    public void someMethodToCreateButtons(){
        JRadioButton observableButton = new JRadioButton("Created here");
        observableButton.addActionListener(observer);
    }

Tous vos JRadioButton sont des objets qui génèrent constamment des ActionEvent , mais personne qui nous tient à cœur ne regarde habituellement, lorsque nous ajoutons un ActionListener nous disons en gros: faites que cet objet ActionListener observe mon comportement.

Nous avons donc besoin de quelqu'un à observer et d'un observateur, laisse faites-les dans votre interface utilisateur (ou une version simplifiée de celle-ci): Puisque vous essayez d'utiliser un écouteur global, vous devez vous assurer qu'il y en a un, observer (notre ActionListener) est nul pour le moment. Permet de l'instancier Cette fois, nous savons que l'observateur n'est pas nul

public class Observer implements ActionListener{
    @Override
    public void ActionPerformed(ActionEvent ae){
        Object source = ae.getSource();
        if (source instanceof JRadioButton)
            ((JRadioButton) source).setText("this works");
    }

Et voilà, quand vous sélectionnez observableButton , il sera changez son texte en "ça marche".

Ce sont les bases, maintenant, j'ai utilisé ces noms observableButton et Observer pour une raison, ActionListeners sont basé sur ce que l'on appelle le modèle de conception d'observateur , vous pourriez prendre un livre sur les modèles de conception, vous ne le regretterez pas.

Enfin, il semble que vous rendez les choses trop difficiles pour vous-même, essayez de simplifier votre logique. Peut-être créer un JPanel contenant différents ensembles de boutons et l'afficher chaque fois qu'une condition est vraie? crache juste ici, mais essayez de rester simple, espérons que cela vous aidera, bonne chance!