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

StackOverflow https://stackoverflow.com/questions/1451152

  •  12-09-2019
  •  | 
  •  

Question

Désolé, je suis nouveau à Java, cette question peut-être pas clair.

Je suis récemment affaire à enfermer une déclaration try et catch dans une boucle while, parce que je voulais vous assurer que l'obtention d'entrée était fermée du reste du programme.

Je suis tombé sur un problème où l'utilisation d'un point d'exclamation (!) Devant une variable dans les conditions de temps (par ex while (! Fait)) au lieu d'utiliser = false (par exemple while (fait = false)) change la façon dont mon programme fonctionne.

Les anciens (!) Fait des résultats dans l'essai et à l'exception des déclarations en cours d'exécution comme prévu. Ce dernier (fait = false) ne porte pas les sauter simplement et de passer à la partie suivante du code.

J'avais l'impression que! avant une variable signifie la même chose que var = false.

je me trompe?

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

À l'heure actuelle, la compilation et l'exécution du programme se fera en douceur: il me demandera un certain nombre, en tapant dans une lettre ou un chiffre très long amène à imprimer le type d'exception et la sortie. En tapant un numéro normal, il provoque pour imprimer le succès!

D'autre part, si je devais remplacer! InputDone avec inputDone = false, il affiche simplement le succès! quand je lance le programme.

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

Était-ce utile?

La solution

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

Donc, si vous utilisez: 

while (done = false)
{
 // code here
}

Alors done est réglé sur false et le code dans la boucle while ne fonctionne pas du tout.

Autres conseils

La déclaration x = false est une mission - vous définissez x à false. Les déclarations x == false et !x sont les mêmes, cependant. La déclaration x == false compare x à faux et sera vrai si la valeur de x est faux et faux si la valeur de x est vrai. La déclaration !x entraînera la négation de la valeur de x.

Dans votre code, si vous remplacez while (!inputDone) avec while(inputDone == false), vous obtiendrez le comportement attendu.

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

"while (fait = false)" est égal à "done = false; while (fait)"

Il doit être écrit "while (fait == false)" ou "tout (faux == fait)".

Mais encore,! Fait est le code le plus lisible, il dire « Inachevé »

Comme beaucoup d'autres l'ont souligné, vous avez typoed ==. Plus intéressants sont les questions entourant ce sujet.

Pour la langue conçue: Encourager les effets secondaires dans les expressions est mauvais. En utilisant le symbole == pour représenter = mathématique est pas un bon choix.

En termes de lisibilité, !done lit beaucoup mieux que done == false - nous voulons « pas fait » (mieux, l'OMI, serait « jusqu'à ce que fait » au lieu de « tout en Inachevé »). Bien que (perpétuelles) newbies écrivent souvent le someCondition == true redondant.

Il est une bonne idée de faire final variables, bien évidemment pas possible dans cette situation. Cependant, nous pouvons enlever le drapeau entièrement à l'aide d'une instruction break. Une opinion minoritaire suit une règle d'entrée unique sortie unique (SESE), dans lequel break est interdit, whcih rendrait cet exemple plus difficile (vous auriez besoin d'un test pour voir si le texte était un int valide, ou dans ce cas, déplacez le corps dans la boucle.

L'expression: 

x = false

signifie affecter la valeur x false.

Après cela se produit dans votre while(), il évalue ensuite x, qui est false il ne pénètre pas dans la boucle du tout.

Par contre: 

while (!x)

signifie « aussi longtemps que! X est vrai, continuer à entrer dans la boucle ». depuis !x signifie « à l'opposé de x ». Donc, tant que x est fausse, la boucle continue

D'autres réponses ont fait allusion au fait que l'écriture x == false et x == true sont mauvais style. Il y a trois raisons à cela:

  • Concision: en supposant que vous êtes dans un contexte où une valeur booléenne est nécessaire, et « x » est une valeur booléenne, il est moins de caractères pour écrire x que x == true ou !x que x == false
    • .
  • Convention: les programmeurs chevronnés en Java (ou C, C ++, C # et la plupart des autres langues) attendent de voir x plutôt que x == true et !x plutôt que x == false
    • .
  • Robustesse: en Java les instructions conditionnelles et boucle nécessitent toutes une expression évaluée booléenne dans la condition. Si y est pas une valeur booléenne, puis 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 booléens vous éviter de vous mettre en place pour toute une série de bugs résultant de fautes de frappe.

Beaucoup ont déjà signalé votre abus de = contre ==. Je voudrais souligner que l'exécution d'un outil d'analyse de code statique comme Findbugs aurait trouvé pour vous tout de suite.

Voir ABQ: Méthode attribue littéral booléen dans l'expression booléenne

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top