La bonne façon d'attendre que les chaînes deviennent égales

Question

Dans une application Swing, une méthode ne doit continuer que lorsque l'utilisateur entre une réponse correcte. La réponse correcte est stockée dans une chaîne, la réponse utilisateur étant définie par un écouteur sur une autre chaîne. Donc, le code est

while (!correctAnswer.equals(currentAnswer)) {
         // wait for user to click the button with the correct answer typed into the textfield
}
// and then continue

Est-ce que tout va bien avec cette approche ou voudriez-vous la refactoriser? N’impose-t-il pas une pénalité supplémentaire au processeur? Voici un peu question similaire .

Answer 1

Êtes-vous nouveau dans la programmation d'interface utilisateur? La raison pour laquelle je vous pose cette question est que votre réponse repose sur un style de codage procédural, ce qui n’est pas ce que sont les interfaces utilisateur. Il a tendance à être événementiel.

Dans ce cas, la solution est assez simple: ajoutez un écouteur d'événements (ActionListener) au bouton d'envoi et vérifiez le résultat à cet endroit. Si ça va, continuez. Sinon, dites-le et laissez-les réessayer.

Answer 2

Comme d'autres l'ont suggéré, vous souhaiterez associer un écouteur au bouton, qui sera appelé lorsque vous appuierez sur le bouton.

Voici un exemple incomplet illustrant l'utilisation d'un ActionListener et implémentation de son actionPerformed qui est appelée lorsque le bouton est enfoncé:

...
final JTextField textField = new JTextField();
final JButton okButton = new JButton("OK");
okButton.addActionListner(new ActionListener() {
    public void actionPerformed(ActionEvent e)
    {
        if ("some text".equals(textField.getText()))
            System.out.println("Yes, text matches.");
        else
            System.out.println("No, text does not match.");
    }
});
...

Vous souhaitez peut-être simplement implémenter < code> ActionListener dans la classe où se trouvent le bouton et le champ de texte; vous n'avez donc pas besoin de déclarer les deux objets comme final . (Je viens d'utiliser une classe interne anonyme pour garder l'exemple court.)

Pour plus d'informations, consultez Comment écrire un écouteur d'action à partir de Didacticiels Java .

De même, pour obtenir des informations générales sur le fonctionnement des événements en Java, reportez-vous au Leçon: Écrire des écouteurs d'événement de The Java Tutorials peut être utile.

Modifier: l'expression < textField.getText (). equals ("du texte") est remplacée par "du texte" .equals (textField.getText ()) afin d'empêcher une NullPointerException si textField était null , par suggestion de M. Shiny et du commentaire de New.

Answer 3

Je ne pense pas comprendre la logique, mais cela me rappelle le bon vieux temps de base ... :-) Je ne vois pas pourquoi l'application oblige l'utilisateur à taper quelque chose de déjà connu (sauf s'il s'agit d'un mot de passe ou quelque chose).

Vous écrivez que la frappe est observée par un auditeur. Alors pourquoi ne pas faire le test là-bas? Ne faites pas de boucle en attente d'un événement, laissez Java le faire (et d'autres choses). Si nécessaire, coupez votre logique en deux et passez à la deuxième partie lorsque vous détectez que la bonne entrée est donnée dans le programme d’écoute.

J'espère que cela a du sens ... ;-)

Answer 4

Oui, comme tout le monde l’a dit ici.

Pour une application graphique, le meilleur moyen de gérer les entrées de l'utilisateur est d'attendre le déclenchement d'un événement.

Ensuite, une méthode peut être utilisée pour valider l'entrée. Si vous réussissez, vous pouvez continuer avec le flux, cela peut être aller sur une autre page.

Voici un exemple complet (mais simple) d’écran de connexion, qui valide la saisie de l’utilisateur et, s’il réussit, exécute une action.

Ce code n'a pas d'autre valeur que celle de montrer dans un exemple complet prêt à exécuter comment ce concept est appliqué.

interface graphique simple http://img229.imageshack.us/img229/1532/simplenz0 .png

// * used for brevity. Preffer single class per import
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.net.*;
import java.io.*;


public class MatchString{

    private final JTextField password;
    private final JFrame frame;

    public static void main( String [] args ){
        MatchString.show();
    }

    public static void show(){
        SwingUtilities.invokeLater( new Runnable(){
            public void run(){
                new MatchString();
            }
        });
    }

    private MatchString(){
        password = new JPasswordField( 20 );
        frame = new JFrame("Go to www.stackoverflow");
        init();
        frame.pack();
        frame.setVisible( true );
    }


    private void init(){

        frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

        frame.add( new JPanel(){{
            add( new JLabel("Password:"));
            add( password );
        }});

        // This is the key of this question.
        // the password textfield is added an 
        // action listener
        // When the user press enter, the method 
        // validatePassword() is invoked.
        password.addActionListener( new ActionListener(){
            public void actionPerformed( ActionEvent e ) {
                validatePassword();
            }
        });
    }


    private void validatePassword(){            
        // If the two strings match
        // then continue with the flow
        // in this case, open SO site.    
        if ( "stackoverflow".equals(password.getText())) try {
            Desktop.getDesktop().browse( new URI("http://stackoverflow.com"));
            frame.dispose();
        } catch ( IOException ioe ){
            showError( ioe.getMessage() );
        } catch ( URISyntaxException use ){
            showError( use.getMessage() );
        } else {
            // If didn't match.. clear the text.
            password.setText("");
        }
    }
 }

Answer 5

Si vos chaînes proviennent d'un utilisateur humain avec des taux d'interface graphique, l'optimisation des performances présente très peu d'intérêt. L'être humain ne pourra pas entrer plus d'une à trois chaînes par seconde, et ce n'est rien pour la machine.

Dans ce cas particulier, où vous devez faire des choses pour obtenir une entrée à tester, je suggérerais d'utiliser un boucle .