Quelle est la différence entre while (x = false) et while (!x) en Java?

Désolé, je suis nouveau sur Java, de sorte que cette question est peut-être pas clair.

J'ai été récemment traitant avec joignant un try et catch déclaration dans une boucle while, parce que je voulais assurez-vous que l'obtention d'entrée était fermée à partir du reste du programme.

J'ai rencontré un problème où l'aide d'un point d'exclamation (!) en face d'une variable dans le temps (par exemple while (!fait)) au lieu d'utiliser = false (par exemple, tandis que (done = false)) modifie la façon dont mon programme fonctionne.

L'ancien (!fait) des résultats de l'essai et à l'exception des déclarations de course comme prévu.
Le dernier (done = false) n'est pas, il suffit de les ignorer et de passer à la partie suivante du code.

J'étais sous l'impression que les ! avant une variable signifiait la même chose que var = false.

Suis-je trompé?

Voici un exemple:

import java.util.Scanner;

public class TestOne {
    public static void main(String args[]) {
        Scanner input = new Scanner(System.in);
        int num;
        boolean inputDone = false;
        while (!inputDone) {
            try {
                System.out.print("Enter in a number here: ");
                num = input.nextInt();
                inputDone = true;
            }
            catch (Exception e) {
                System.out.println(e);
                System.exit(0);
            }
        }
        System.out.println("Success!");
    }
}

Actuellement, la compilation et l'exécution du programme se fait en douceur: il va me demander pour un certain nombre, en tapant une lettre ou un très long nombre de causes pour imprimer le type d'exception et de sortie. En tapant un nombre normal provoque l'impression de Réussite!

D'autre part, si j'étais à la place de !inputDone avec inputDone = false, il imprime simplement un Succès! quand je lance le programme.

Quelqu'un peut-il expliquer la différence pour moi entre les ! et l' = fausses déclarations dans une boucle while?

x == false est mauvais style, presque aussi mauvais que x == true.
J'aime que la faute dans la question du titre est la raison pour jamais écrit lvalue == false

OriginalL'auteur akbiggs | 2009-09-20

16

Noter la différence entre done = false et done == false. Le premier attribue done être false et évalue comme false, le second compare done avec false et est exactement identique à !done.

Donc si vous l'utilisez:
```
while (done = false)
{
 //code here
}
```
Puis done est fixé à false et le code dans la boucle while ne fonctionne pas du tout.

Merci. C'est la deuxième erreur, ces derniers temps, j'ai oublié que le deuxième point d'exclamation.
err, pas de point d'exclamation; signe égal. LOL.
si vous sortez de la (MAUVAISE) habitude de explicitement la comparaison des valeurs booléennes avec"==", vous ne ferez pas cette erreur.

OriginalL'auteur Joren
4

La déclaration x = false est une mission - vous êtes la configuration de x pour faux. Les déclarations x == false et !x sont cependant les mêmes. La déclaration x == false compare x pour faux et sera true si la valeur de x est faux et faux si la valeur de x est vrai. La déclaration !x sera le résultat de la négation de la valeur de x.

Dans votre code, si vous remplacez while (!inputDone) avec while(inputDone == false), vous permettra d'obtenir le comportement attendu.

Ohh, haha. Wow, je ne peux pas croire que j'ai manqué. Merci!

OriginalL'auteur Thomas Owens
3

Vous devez utiliser == au lieu de = pour les comparaisons.

OriginalL'auteur João Silva
2

"while(done = false)" est égale à "done=false; while(terminé)"

Il devrait être écrit "while(done == false)" ou "while(false == terminé)".

Mais encore , !fait est le plus lisible le code, il dit "ne PAS FAIRE"

Il devrait être écrit comme while (!done) {.
l'écriture de "while (done == false) ..." qui fonctionne le mieux pour moi. J'ai tendance à négliger ces satanés points d'exclamation.

OriginalL'auteur Dennis C
2

Comme beaucoup d'autres l'ont souligné, vous avez typoed ==. Plus intéressantes sont les questions qui entourent cette.

De langage conçu: Encourager les effets secondaires des expressions est mauvais. En utilisant le symbole == pour représenter les mathématiques = n'est pas un bon choix.

En termes de lisibilité, !done lit beaucoup mieux que done == false - nous voulons "pas fait" (mieux, de l'OMI, serait "jusqu'à ce que fait" au lieu de "tout n'est pas réalisé"). Bien que (perpétuel) débutants écris souvent redondants someCondition == true.

C'est une bonne idée de faire des variables final, bien que clairement pas possible dans cette situation. Cependant, on peut retirer le drapeau entièrement à l'aide d'une instruction break. Une minorité suit une Seule Entrée, de Sortie Unique (SESE) de la règle, en vertu de laquelle break est interdit, ce qui ferait de cet exemple plus compliqué (vous auriez besoin d'un test pour voir si le texte était valide int, ou dans ce cas, déplacer le corps dans la boucle.

OriginalL'auteur Tom Hawtin - tackline
2

L'expression:
```
x = false
```
signifie attribuer x la valeur false.

Après ce qui se passe dans votre while(), il évalue alors x, qui est false afin de ne pas entrer dans la boucle.

D'autre part:
```
while (!x)
```
signifie "aussi longtemps que !x est vrai, continuer la saisie de la boucle". depuis !x signifie "à l'opposé de x". Donc, tant que x est fausse, la boucle sera

OriginalL'auteur Mike
1

D'autres réponses ont fait allusion au fait que l'écriture x == false et x == true sont de mauvais style. Il y a trois raisons à cela:
- La concision: en supposant que vous êtes dans un contexte où un Boolean, et "x" est un Booléen, c'est moins de caractères à écrire x que x == true, ou !x que x == false.
- Convention: assaisonnée programmeurs en Java (ou C, C++, C# et la plupart des autres langues) attendez-vous à voir x plutôt que x == true, et !x plutôt que x == false.
- Robustesse: en Java, du conditionnel et de la boucle de tous les états exigent un Boolean expression de valeur dans la condition. Si y n'est pas un Booléen, une faute de frappe de la forme if (y = foo) { donnera une erreur de compilation en Java. Mais si y est un Booléen alors if (y = foo) { ne donne pas une erreur de compilation. Par conséquent, en évitant == pour les Booléens vous éviter de vous-même la mise en place de toute une série de bugs résultant de fautes de frappe.
OriginalL'auteur Stephen C
0

Beaucoup l'ont déjà souligné d'une mauvaise utilisation de = vs ==. Je tiens à souligner que l'exécution d'une analyse de code statique outil comme Findbugs aurait trouvé cela pour vous.

Voir QBA: Méthode attribue boolean littérales d'expressions booléennes

OriginalL'auteur Jeff Olson

Vous devez vous connecter pour publier un commentaire.