En Java, quelles sont les booléen « ordre des opérations »?

Question

Prenons un exemple simple d'un Cat objet. Je veux être sûr que le cat est orange ou gris « non nulle ».

if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") {
//do stuff
}

Je crois et vient d'abord, puis l'OR. Je suis bien un peu floue, alors voici mes questions:

1. Quelqu'un peut-il me promener à travers cette déclaration, donc je suis sûr que je reçois ce qui se passe?

2. De plus, ce qui se passe si j'ajoute entre parenthèses; ce que ça change l'ordre des opérations?

3. Ma commande d'opérations changer de langue en langue?

Answer 1

Le Java Tutoriels a une liste illustrant opérateur rel="noreferrer"> . Les opérateurs d'égalité seront évalués d'abord, puis &&, puis ||. Parenthèses seront évalués avant toute autre chose, afin de les ajouter peuvent changer l'ordre. Ceci est généralement à peu près la même chose de la langue à la langue, mais il est toujours une bonne idée de vérifier.

Ce sont les petites variations dans le comportement que vous ne m'y attendais pas peut vous faire passer un débogage de journée, il est donc une bonne idée de mettre les parenthèses en place de sorte que vous êtes sûr de ce que l'ordre d'évaluation sera.

Answer 2

Ordre des opérations booléennes (dans toutes les langues, je crois):

1. parens
2. PAS
3. et
4. ou

Ainsi, votre logique ci-dessus est équivalente à:

(cat != null && cat.getColor() == "orange") || cat.getColor() == "grey"

Answer 3

L'expression est fondamentalement identique à:

if ( (cat != null && cat.getColor() == "orange") || cat.getColor() == "grey") {
  ...
}

L'ordre de priorité est que ET (&&) a priorité supérieure ou (||).

Il faut savoir aussi que l'utilisation == pour tester l'égalité cordes sont parfois travail en Java, mais il est pas comment vous devriez le faire. Vous devez faire:

if (cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
  ...
}

à savoir utiliser les méthodes de equals() pour la comparaison des String, non == qui ne fonctionne tout simplement l'égalité de référence. l'égalité de référence pour les chaînes peut induire en erreur. Par exemple:

String a = new String("hello");
String b = new String("hello");
System.out.println(a == b); // false

Answer 4

Oui && est certainement évalué avant ||. Mais je vois que vous faites cat.getColor() == "orange" qui pourrait vous donner des résultats inattendus. Vous voudrez peut-être ceci:

if(cat != null && ("orange".equals(cat.getColor()) || "grey".equals(cat.getColor()))) {
    //do stuff
}

Answer 5

D'abord, votre instruction if contient trois expressions principales:

1. chat! = Null
2. cat.getColor () == "orange"
3. cat.getColor () == "gris"

La première expression vérifie simplement si le chat est non nul. Son nécessaire sinon la deuxième expression sera exécutée et s'entraînera une NPE(null pointer excpetion). Voilà pourquoi l'utilisation de && entre la première et la deuxième expression. Lorsque vous utilisez &&, si la première expression est fausse la deuxième expression est jamais exécutée. Enfin, vous vérifier si la couleur du chat est gris.

  

À noter enfin que votre instruction if est   encore mauvais parce que si le chat est   null, la troisième expression est encore   et donc exécutiez vous obtenez une valeur nulle   exception de pointeur .

La bonne façon de le faire est:

if(cat != null && (cat.getColor() == "orange" || cat.getColor() == "grey")) { 
//do stuff 
} 

Vérifier l'ordre de parenthèses.

Answer 6

Ordre de fonctionnement est pas ce que vous avez besoin, vous avez besoin d'algèbre booléenne, cela inclut des fonctions booléennes. Maxterms / minterms, code Gray, tables Karnaugh, diodes, transistors, portes logiques, multiplexeurs, bitadders, tongs ... Ce que vous voulez est de mettre en œuvre « logique » booléenne sur des ordinateurs ou des machines virtuelles. Avec « l'ordre des opérations » vous pouvez vous référer quelque chose sur la physique comme la gestion des retards sur les portes logiques (ou, si) des intervalles nanosecondes?